feat(ts): surface SDL reclamation from generateManifest (#318)

* feat(ts): surface SDL reclamation from generateManifest

`generateManifest` validated the deployment-level `reclamation` block
structurally (JSON schema) but dropped it, and TS had no Go-duration
parser to turn `min_window` ("24h") into a proto `Duration`. Go does
this in `go/sdl/reclamation.go` (`toDeploymentReclamation`), so TS was
behind Go and console could not populate `MsgCreateDeployment.reclamation`.

This adds Go/TS parity:
- `parseGoDuration`: a dependency-free port of Go's `time.ParseDuration`
  (all units incl. both micro-sign variants, signed, fractional, compound).
  Accumulates in BigInt so year-scale windows (e.g. "8760h" = 3.1536e16 ns,
  past Number.MAX_SAFE_INTEGER) keep full precision, and mirrors Go's
  int64-ns overflow ceiling.
- `SDLValidator` rejects an unparseable or <= 0 `min_window`, mirroring Go's
  `validate()` (v2.go / v2_1.go). Reclamation is version-agnostic: Go accepts
  the block in both v2.0 and v2.1, so there is no version gate.
- `generateManifest` returns the parsed reclamation as a `DeploymentReclamation`
  on its result, alongside `groupSpecs` (both are `MsgCreateDeployment` fields,
  not manifest groups).

Parsing lives upstream here (rather than in console) for Go/TS parity.

* refactor(ts): tidy reclamation validation cleanup

- extract a shared baseError in #validateReclamation so only the message
  differs between the invalid-duration and non-positive cases
- drop the no-op NS identity helper from parseGoDuration.spec

* refactor(ts): constrain reclamation min_window via schema pattern

Replace the ~170-line hand-rolled `time.ParseDuration` port with a schema
`pattern` (^[1-9][0-9]*(s|m|h)$) on `min_window` plus a ~10-line converter.

The shared SDL schema (compiled into the TS ajv validator, embedded in the Go
binary) now enforces both the format and `> 0` declaratively, the same way cpu
units / storage paths / price are. `minWindowToDuration` turns the validated
string into a proto Duration as an exact second count (nanos always 0, no
BigInt/fractional/overflow handling).

The allowed set is a strict subset of what Go's `time.ParseDuration` accepts, so
there is no "TS accepts / chain rejects" divergence. Go stays the lenient layer
(reclamation.go unchanged); rejecting compound/fractional/sub-second/zero/signed
forms is the sanctioned schema-only-invalid category, locked by a new fixture.

* refactor(ts): make generateManifest reclamation a lazy getter

Per review: reclamation is a `MsgCreateDeployment` field that isn't needed in
every call, so compute it on access like `groups`/`groupSpecs` instead of
eagerly. Memoized so repeated reads return the same instance.

* refactor(ts): simplify reclamation duration parsing and getter

- drop regex in minWindowToDuration for direct unit/amount parsing on the
  hot path; keep cheap integer/positivity/unit guards to preserve the
  defensive contract
- remove redundant reclamationComputed flag; memoize via !reclamation

* refactor(ts): use String.at(-1) for reclamation unit lookup

Author: baktun14

go/sdl/sdl-input.schema.yaml

@@ -492,10 +492,10 @@ properties:
     properties:
       min_window:
         type: string
+        pattern: "^[1-9][0-9]*(s|m|h)$"
         description: >-
-          Minimum reclamation window duration the tenant requires.
-          Go duration format (e.g. "1h", "24h", "720h").
-        minLength: 1
+          Minimum reclamation window the tenant requires, as a whole number
+          followed by a unit (s, m, or h). E.g. "1h", "24h", "720h".
     required:
       - min_window
     type: object

testdata/sdl/input/invalid/v2.1-reclamation-bad-window.yaml

@@ -0,0 +1,36 @@
+# yaml-language-server: $schema=../../../../go/sdl/sdl-input.schema.yaml
+---
+version: "2.1"
+services:
+  web:
+    image: nginx:latest
+    expose:
+      - port: 80
+        as: 80
+        to:
+          - global: true
+profiles:
+  compute:
+    web:
+      resources:
+        cpu:
+          units: 100m
+        memory:
+          size: 512Mi
+        storage:
+          size: 512Mi
+  placement:
+    akash:
+      pricing:
+        web:
+          denom: uakt
+          amount: 1000
+deployment:
+  web:
+    akash:
+      profile: web
+      count: 1
+reclamation:
+  # Structurally valid (non-empty string) but semantically invalid: a window of
+  # zero is rejected by the Go-parity check (min_window must be > 0).
+  min_window: "0s"

testdata/sdl/input/schema-only-invalid/reclamation-compound-window.yaml

@@ -0,0 +1,37 @@
+# yaml-language-server: $schema=../../../../go/sdl/sdl-input.schema.yaml
+---
+version: "2.1"
+services:
+  web:
+    image: nginx:latest
+    expose:
+      - port: 80
+        as: 80
+        to:
+          - global: true
+profiles:
+  compute:
+    web:
+      resources:
+        cpu:
+          units: 100m
+        memory:
+          size: 512Mi
+        storage:
+          size: 512Mi
+  placement:
+    akash:
+      pricing:
+        web:
+          denom: uakt
+          amount: 1000
+deployment:
+  web:
+    akash:
+      profile: web
+      count: 1
+reclamation:
+  # Accepted by Go's time.ParseDuration (compound, 90m > 0) but rejected by the
+  # stricter schema pattern (^[1-9][0-9]*(s|m|h)$). Schema-only-invalid: schema
+  # rejects, Go parser accepts.
+  min_window: "1h30m"

ts/src/sdl/manifest/generateManifest.spec.ts

@@ -806,6 +806,45 @@ describe(generateManifest.name, () => {
     });
   });
 
+  describe("reclamation", () => {
+    it.each([
+      ["24h", "86400"],
+      ["30m", "1800"],
+      ["720h", "2592000"],
+      ["8760h", "31536000"],
+    ])("surfaces min_window %j as a proto Duration (%s seconds)", (minWindow, seconds) => {
+      const { result } = setup({ sdl: createBasicSdl({ reclamation: { min_window: minWindow } }) });
+      expect(result.reclamation?.minWindow?.seconds.toString()).toBe(seconds);
+      expect(result.reclamation?.minWindow?.nanos).toBe(0);
+    });
+
+    it("leaves reclamation undefined when no block is present", () => {
+      const { result } = setup();
+      expect(result.reclamation).toBeUndefined();
+    });
+
+    // Compound ("1h30m"), fractional ("1.5h") and sub-second ("500ms") forms are
+    // accepted by Go's `time.ParseDuration` but rejected by the stricter SDL
+    // schema pattern (`^[1-9][0-9]*(s|m|h)$`).
+    it.each(["abc", "0s", "-1h", "100", "1h30m", "1.5h", "500ms"])("rejects an invalid min_window %j", (minWindow) => {
+      const result = generateManifest(createBasicSdl({ reclamation: { min_window: minWindow } }));
+      expect(result.ok).toBe(false);
+      if (!result.ok) {
+        expect(result.value).toContainEqual(expect.objectContaining({
+          instancePath: "/reclamation/min_window",
+        }));
+      }
+    });
+
+    it("exposes reclamation as a lazy, memoized getter", () => {
+      const { result } = setup({ sdl: createBasicSdl({ reclamation: { min_window: "24h" } }) });
+      // It's a getter (computed on access, not eagerly)...
+      expect(Object.getOwnPropertyDescriptor(result, "reclamation")?.get).toBeTypeOf("function");
+      // ...and memoized: repeated reads return the same instance.
+      expect(result.reclamation).toBe(result.reclamation);
+    });
+  });
+
   function setup(input?: {
     sdl: SDLInput;
   }) {
@@ -837,6 +876,7 @@ describe(generateManifest.name, () => {
     credentials?: SDLInput["services"][string]["credentials"];
     expose?: SDLInput["services"][string]["expose"];
     endpoints?: SDLInput["endpoints"];
+    reclamation?: SDLInput["reclamation"];
   } = {}): SDLInput {
     const {
       port = 80,
@@ -880,6 +920,7 @@ describe(generateManifest.name, () => {
             profile: web
             count: 1
       endpoints: ${input.endpoints}
+      reclamation: ${input.reclamation}
     `;
   }
 

ts/src/sdl/manifest/generateManifest.ts

@@ -4,6 +4,7 @@ import { GPU } from "../../generated/protos/akash/base/resources/v1beta4/gpu.ts"
 import { Memory } from "../../generated/protos/akash/base/resources/v1beta4/memory.ts";
 import { Resources } from "../../generated/protos/akash/base/resources/v1beta4/resources.ts";
 import { Storage } from "../../generated/protos/akash/base/resources/v1beta4/storage.ts";
+import { DeploymentReclamation } from "../../generated/protos/akash/deployment/v1/deployment.ts";
 import { GroupSpec } from "../../generated/protos/akash/deployment/v1beta4/groupspec.ts";
 import { ResourceUnit } from "../../generated/protos/akash/deployment/v1beta4/resourceunit.ts";
 import { Group } from "../../generated/protos/akash/manifest/v2beta3/group.ts";
@@ -29,10 +30,12 @@ import {
   type SDLService,
   transformGpuAttributes,
 } from "./manifestUtils.ts";
+import { minWindowToDuration } from "./reclamationDuration.ts";
 
 export interface GenerateManifestOkResult {
   groups: Group[];
   groupSpecs: GroupSpec[];
+  reclamation?: DeploymentReclamation;
 }
 
 export type Manifest = GenerateManifestOkResult["groups"];
@@ -143,8 +146,21 @@ export function generateManifest(sdl: SDLInput): GenerateManifestResult {
   const sortedGroupNames = [...groupsMap.keys()].sort();
   let groups: Group[] | undefined;
   let groupSpecs: GroupSpec[] | undefined;
+  let reclamation: DeploymentReclamation | undefined;
 
   const manifest = {
+    // reclamation is a `MsgCreateDeployment` field, not a manifest group, and is
+    // not needed in every call — so it's lazy like `groups`/`groupSpecs`.
+    // `validateSDL` (run above) already guaranteed `min_window` is valid, so
+    // `minWindowToDuration` never throws here.
+    get reclamation() {
+      if (sdl.reclamation && !reclamation) {
+        reclamation = DeploymentReclamation.fromPartial({
+          minWindow: minWindowToDuration(sdl.reclamation.min_window),
+        });
+      }
+      return reclamation;
+    },
     get groups() {
       groups ??= sortedGroupNames.map((placementName) => {
         const deployments = deploymentsByPlacement.get(placementName)!;

ts/src/sdl/manifest/reclamationDuration.spec.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest";
+
+import { minWindowToDuration } from "./reclamationDuration.ts";
+
+describe("minWindowToDuration", () => {
+  it.each([
+    ["1s", "1"],
+    ["30m", "1800"],
+    ["1h", "3600"],
+    ["24h", "86400"],
+    ["720h", "2592000"],
+    ["8760h", "31536000"], // year-scale window: exact seconds, no precision loss
+  ])("converts %j to %s seconds with zero nanos", (input, seconds) => {
+    const duration = minWindowToDuration(input);
+    expect(duration.seconds.toString()).toBe(seconds);
+    expect(duration.nanos).toBe(0);
+  });
+
+  // Defensive: the SDL schema pattern guarantees a valid format upstream, but a
+  // direct call with a value the schema would have rejected throws clearly.
+  it.each(["1h30m", "1.5h", "500ms", "0s", "-1h", "100", "abc", ""])("throws on the schema-rejected value %j", (input) => {
+    expect(() => minWindowToDuration(input)).toThrow(/invalid reclamation min_window/);
+  });
+});

ts/src/sdl/manifest/reclamationDuration.ts

@@ -0,0 +1,21 @@
+import { Duration } from "../../generated/protos/google/protobuf/duration.ts";
+
+const UNIT_SECONDS: Record<string, bigint> = { s: 1n, m: 60n, h: 3600n };
+
+/**
+ * Converts a reclamation `min_window` into a proto `Duration`. The SDL schema
+ * pattern (`^[1-9][0-9]*(s|m|h)$`) has already guaranteed the format (and `> 0`)
+ * before this runs, so on the request hot path we split off the trailing unit
+ * and parse the amount directly instead of re-running a regex. The cheap
+ * unit/integer/positivity guards stay only to reject obviously-invalid direct
+ * calls. Whole-unit windows are an exact second count, so `nanos` is always 0
+ * and the BigInt product never loses precision.
+ */
+export function minWindowToDuration(value: string): Duration {
+  const unitSeconds = UNIT_SECONDS[value.at(-1) ?? ""];
+  const amount = Number(value.slice(0, -1));
+  if (unitSeconds === undefined || !Number.isInteger(amount) || amount <= 0) {
+    throw new Error(`invalid reclamation min_window "${value}"`);
+  }
+  return Duration.fromPartial({ seconds: (BigInt(amount) * unitSeconds).toString(), nanos: 0 });
+}

ts/src/sdl/validateSDL/validateSDL.spec.ts

@@ -2190,6 +2190,42 @@ describe(validateSDL.name, () => {
     });
   });
 
+  describe("reclamation validation", () => {
+    it.each(["24h", "720h", "8760h", "30m", "1s"])("accepts a valid min_window %j", (minWindow) => {
+      const { validate } = setup({ reclamation: { min_window: minWindow } });
+      expect(validate()).toBeUndefined();
+    });
+
+    it("accepts reclamation on a v2.0 SDL (version-agnostic)", () => {
+      const { validate } = setup({ version: "2.0", reclamation: { min_window: "720h" } });
+      expect(validate()).toBeUndefined();
+    });
+
+    it("accepts reclamation on a v2.1 SDL", () => {
+      const { validate } = setup({ version: "2.1", reclamation: { min_window: "30m" } });
+      expect(validate()).toBeUndefined();
+    });
+
+    it("returns no reclamation error when the block is absent", () => {
+      const { validate } = setup();
+      expect(validate()).toBeUndefined();
+    });
+
+    // The schema pattern is intentionally stricter than Go's `time.ParseDuration`:
+    // it rejects compound ("1h30m"), fractional ("1.5h"), sub-second units
+    // ("500ms"), signs, zero, and unitless values, leaving only whole s/m/h
+    // windows. Go stays the lenient layer (see go/sdl/reclamation.go).
+    it.each(["abc", "0s", "-1h", "100", "1h30m", "1.5h", "500ms"])("rejects an invalid min_window %j", (minWindow) => {
+      const { validate } = setup({ reclamation: { min_window: minWindow } });
+      expect(validate()).toContainEqual(expect.objectContaining({
+        instancePath: "/reclamation/min_window",
+        schemaPath: "#/properties/reclamation/properties/min_window/pattern",
+        keyword: "pattern",
+        message: expect.stringContaining("whole number followed by s, m, or h"),
+      }));
+    });
+  });
+
   function setup(overrides: DeepPartial<SDLInput> = {}, networkId: NetworkId = "sandbox") {
     const defaultSDL: SDLInput = {
       version: "2.0",

ts/src/sdl/validateSDL/validateSDL.ts

@@ -13,6 +13,12 @@ const ERROR_MESSAGES: ErrorMessages = {
   "#/definitions/exposeToWithIpEnforcesGlobal"() {
     return `If an IP is declared, the directive must be declared as global.`;
   },
+  // Mirrors the shared schema's `min_window` pattern (`^[1-9][0-9]*(s|m|h)$`).
+  // Go stays the lenient layer (`go/sdl/reclamation.go` accepts any `> 0`
+  // `time.ParseDuration`), so this is a sanctioned schema-only-stricter rule.
+  "#/properties/reclamation/properties/min_window/pattern"() {
+    return `Reclamation min_window must be a whole number followed by s, m, or h (e.g. "24h", "30m").`;
+  },
 };
 
 export function validateSDL(sdl: SDLInput): undefined | ValidationError[] {