@rotorsoft/act-tck 1.39.2 → 1.41.0

package/dist/@types/stability-tck.d.ts

@@ -4,7 +4,8 @@
  * @property name - Display name for the snapshot suite (e.g., the package
  *   name). Used as the `describe` block label so failing snapshots are
  *   attributable at a glance.
- * @property entryPoints - Map of subpath → entry source file. The TCK
+ * @property entryPoints - Map of subpath → entry file, either source
+ *   (`.ts`) or a published declaration (`.d.ts`). The TCK
  *   reads each entry, follows its relative re-exports recursively, and
  *   snapshots the resulting surface text. Empty-string subpaths label
  *   the root entry; everything else is rendered with its key (e.g.
@@ -15,8 +16,8 @@ export type StabilityTckOptions = {
     readonly entryPoints: Readonly<Record<string, string>>;
 };
 /**
- * Snapshot-based public-API stability check. Walks each entry's source
- * file plus everything it re-exports through relative imports, and
+ * Snapshot-based public-API stability check. Walks each entry file plus
+ * everything it re-exports through relative imports, and
  * compares the concatenated text against a committed Vitest snapshot.
  *
  * Catches accidental rename / removal / signature drift on the public
@@ -24,9 +25,13 @@ export type StabilityTckOptions = {
  * shows up as a snapshot diff in the PR; reviewers either accept the
  * change (update the snapshot deliberately) or push back.
  *
- * The TCK reads source (`.ts`) rather than built declarations so it
- * doesn't need a prior `pnpm build`. It follows `from "./relative.js"`
- * re-exports transitively; non-relative paths (other packages, `node:`)
+ * Point it at the built declarations (`.d.ts`) to record the surface
+ * alone: a change to implementation then leaves the snapshot alone, and
+ * doc comments still show. That needs a build first. Point it at source
+ * (`.ts`) to skip the build, at the cost of a snapshot that also moves
+ * with every implementation change. It follows `from "./relative.js"`
+ * re-exports transitively, to `.d.ts` from a declaration and to `.ts`
+ * from source; non-relative paths (other packages, `node:`)
  * stop the walk — drift in another package's surface is that package's
  * stability TCK to catch.
  *

package/dist/@types/stability-tck.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stability-tck.d.ts","sourceRoot":"","sources":["../../src/stability-tck.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACxD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAUlE"}
+{"version":3,"file":"stability-tck.d.ts","sourceRoot":"","sources":["../../src/stability-tck.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACxD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAUlE"}

package/dist/@types/store-tck.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"store-tck.d.ts","sourceRoot":"","sources":["../../src/store-tck.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAQV,KAAK,EAIN,MAAM,sBAAsB,CAAC;AAe9B;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B;;;;;;;;;OASG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IACrC;;;;;;;OAOG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IACjC;;;;;;;;;OASG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IACpC;;;;;;;;OAQG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;IAClC;;;;;;;OAOG;IACH,QAAQ,CAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IACxC;;;;;;;;OAQG;IACH,QAAQ,CAAC,gCAAgC,CAAC,EAAE,OAAO,CAAC;IACpD;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC7B,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAC/C;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IACxD;;OAEG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,iBAAiB,CAAC;CAC3C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,WAAW,YAAa,eAAe,KAAG,IAmiLtD,CAAC"}
+{"version":3,"file":"store-tck.d.ts","sourceRoot":"","sources":["../../src/store-tck.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAUV,KAAK,EAIN,MAAM,sBAAsB,CAAC;AAe9B;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B;;;;;;;;;OASG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IACrC;;;;;;;OAOG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IACjC;;;;;;;;;OASG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IACpC;;;;;;;;OAQG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;IAClC;;;;;;;OAOG;IACH,QAAQ,CAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IACxC;;;;;;;;OAQG;IACH,QAAQ,CAAC,gCAAgC,CAAC,EAAE,OAAO,CAAC;IACpD;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC7B,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAC/C;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IACxD;;OAEG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,iBAAiB,CAAC;CAC3C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,WAAW,YAAa,eAAe,KAAG,IAiwLtD,CAAC"}

package/dist/index.cjs

@@ -418,8 +418,9 @@ async function load_surface(entry2) {
     const content = await import_node_fs.promises.readFile(abs, "utf8");
     visited.set(abs, content);
     const re_export = /^\s*export\b[^"';]*\bfrom\s+["'](\.[^"']+)["']/gm;
+    const ext = abs.endsWith(".d.ts") ? ".d.ts" : ".ts";
     for (const m of content.matchAll(re_export)) {
-      const rel = m[1].replace(/\.js$/, ".ts");
+      const rel = m[1].replace(/\.js$/, ext);
       const target = import_node_path.default.resolve(import_node_path.default.dirname(abs), rel);
       await walk(target);
     }
@@ -4590,6 +4591,191 @@ var runStoreTck = (options) => {
         (0, import_vitest9.expect)(positions).toEqual([s]);
       });
     });
+    (0, import_vitest9.describe)("schema-driven dates on read", () => {
+      const actor2 = { id: "reader", name: "Reader" };
+      const reader = (shape) => {
+        const Happened = import_zod2.z.object(shape);
+        return (0, import_act2.state)({ Reader: import_zod2.z.object({ n: import_zod2.z.number() }) }).init(() => ({ n: 0 })).emits({ Happened }).patch({ Happened: (_, s) => ({ n: s.n + 1 }) }).on({ Do: Happened }).emit((p) => ["Happened", p]).build();
+      };
+      const over = async (S) => {
+        const fresh = await options.factory();
+        await fresh.seed();
+        const cache = new import_act2.InMemoryCache();
+        const app = (0, import_act2.act)().withState(S).build({ scoped: { store: fresh, cache } });
+        const stream = `dt-${uid()}`;
+        const read = async () => (await app.query_array({ stream, stream_exact: true }))[0].data;
+        const done = async () => {
+          await app.shutdown();
+          await cache.dispose();
+          await fresh.dispose();
+        };
+        return { app, fresh, cache, stream, read, done };
+      };
+      const raw = { correlation: "c", causation: {} };
+      (0, import_vitest9.it)("types z.date() and leaves an ISO-shaped z.string() alone, warm and cold", async () => {
+        const at = /* @__PURE__ */ new Date("2026-01-01T00:00:00.000Z");
+        const label = "2026-06-06T00:00:00.000Z";
+        const S = reader({ at: import_zod2.z.date(), label: import_zod2.z.string() });
+        const t = await over(S);
+        try {
+          await t.app.do("Do", { stream: t.stream, actor: actor2 }, { at, label });
+          const warm = await t.read();
+          await t.cache.clear();
+          const cold = await t.read();
+          for (const d of [warm, cold]) {
+            (0, import_vitest9.expect)(d.at).toBeInstanceOf(Date);
+            (0, import_vitest9.expect)(d.at.getTime()).toBe(at.getTime());
+            (0, import_vitest9.expect)(d.label).toBe(label);
+          }
+        } finally {
+          await t.done();
+        }
+      });
+      (0, import_vitest9.it)("revives a date through every wrapper the rebuild knows", async () => {
+        const S = reader({
+          a: import_zod2.z.date(),
+          b: import_zod2.z.date().default(/* @__PURE__ */ new Date(0)),
+          t: import_zod2.z.tuple([import_zod2.z.date(), import_zod2.z.string()]),
+          td: import_zod2.z.tuple([import_zod2.z.string(), import_zod2.z.string()]),
+          r: import_zod2.z.date().readonly(),
+          c: import_zod2.z.date().catch(/* @__PURE__ */ new Date(0)),
+          n: import_zod2.z.date().optional().nonoptional(),
+          p: import_zod2.z.date().prefault(/* @__PURE__ */ new Date(0)),
+          u: import_zod2.z.union([import_zod2.z.date(), import_zod2.z.string()]),
+          l: import_zod2.z.array(import_zod2.z.date()),
+          m: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.date()),
+          o: import_zod2.z.object({ deep: import_zod2.z.date() }),
+          x: import_zod2.z.date().nullable()
+        });
+        const t = await over(S);
+        try {
+          const when = /* @__PURE__ */ new Date("2022-01-01");
+          await t.app.do(
+            "Do",
+            { stream: t.stream, actor: actor2 },
+            {
+              a: /* @__PURE__ */ new Date("2020-01-01"),
+              b: /* @__PURE__ */ new Date("2021-01-01"),
+              t: [when, "x"],
+              td: ["no", "dates"],
+              r: when,
+              c: when,
+              n: when,
+              p: when,
+              u: when,
+              l: [when],
+              m: { k: when },
+              o: { deep: when },
+              x: null
+            }
+          );
+          const d = await t.read();
+          for (const key of ["a", "b", "r", "c", "n", "p", "u"])
+            (0, import_vitest9.expect)(d[key], key).toBeInstanceOf(Date);
+          (0, import_vitest9.expect)(d.t[0]).toBeInstanceOf(Date);
+          (0, import_vitest9.expect)(d.t[1]).toBe("x");
+          (0, import_vitest9.expect)(d.td).toEqual(["no", "dates"]);
+          (0, import_vitest9.expect)(d.l[0]).toBeInstanceOf(Date);
+          (0, import_vitest9.expect)(d.m.k).toBeInstanceOf(Date);
+          (0, import_vitest9.expect)(d.o.deep).toBeInstanceOf(Date);
+          (0, import_vitest9.expect)(d.x).toBeNull();
+        } finally {
+          await t.done();
+        }
+      });
+      (0, import_vitest9.it)("revives dates in a payload that predates the declaration", async () => {
+        const S = reader({ at: import_zod2.z.date(), label: import_zod2.z.string() });
+        const t = await over(S);
+        try {
+          await t.fresh.commit(
+            t.stream,
+            [{ name: "Happened", data: { at: /* @__PURE__ */ new Date("2020-01-01") } }],
+            raw,
+            -1
+          );
+          const d = await t.read();
+          (0, import_vitest9.expect)(d.label).toBeUndefined();
+          (0, import_vitest9.expect)(d.at).toBeInstanceOf(Date);
+        } finally {
+          await t.done();
+        }
+      });
+      (0, import_vitest9.it)("hands back what is stored when a date field holds something else", async () => {
+        const S = reader({ at: import_zod2.z.date() });
+        const t = await over(S);
+        try {
+          await t.fresh.commit(
+            t.stream,
+            [{ name: "Happened", data: { at: "not a date" } }],
+            raw,
+            -1
+          );
+          (0, import_vitest9.expect)((await t.read()).at).toBe("not a date");
+        } finally {
+          await t.done();
+        }
+      });
+      import_vitest9.describe.skipIf(!caps.pii_isolation)("with sensitive fields", () => {
+        (0, import_vitest9.it)("reads a redacted payload whose required sensitive field lives in pii", async () => {
+          const S = reader({ at: import_zod2.z.date(), email: (0, import_act2.sensitive)(import_zod2.z.string()) });
+          const t = await over(S);
+          try {
+            const target = { stream: t.stream, actor: actor2 };
+            await t.app.do("Do", target, { at: /* @__PURE__ */ new Date(0), email: "u@x.io" });
+            const d = await t.read();
+            (0, import_vitest9.expect)(d.at).toBeInstanceOf(Date);
+            (0, import_vitest9.expect)(d.email).toBe("[REDACTED]");
+            (0, import_vitest9.expect)((await t.app.load(S, t.stream)).state.n).toBe(1);
+            await t.app.do("Do", target, { at: /* @__PURE__ */ new Date(1), email: "v@x.io" });
+          } finally {
+            await t.done();
+          }
+        });
+        (0, import_vitest9.it)("keeps a redacted sensitive date's sentinel", async () => {
+          const S = reader({ at: import_zod2.z.date(), born: (0, import_act2.sensitive)(import_zod2.z.date()) });
+          const t = await over(S);
+          try {
+            await t.app.do(
+              "Do",
+              { stream: t.stream, actor: actor2 },
+              { at: /* @__PURE__ */ new Date(0), born: /* @__PURE__ */ new Date(1) }
+            );
+            const d = await t.read();
+            (0, import_vitest9.expect)(d.at).toBeInstanceOf(Date);
+            (0, import_vitest9.expect)(d.born).toBe("[REDACTED]");
+          } finally {
+            await t.done();
+          }
+        });
+        (0, import_vitest9.it)("hands a disclosed sensitive date to the reducer as a Date", async () => {
+          const seen = {};
+          const Happened = import_zod2.z.object({
+            at: import_zod2.z.date(),
+            born: (0, import_act2.sensitive)(import_zod2.z.date())
+          });
+          const S = (0, import_act2.state)({ Disclosed: import_zod2.z.object({ n: import_zod2.z.number() }) }).init(() => ({ n: 0 })).emits({ Happened }).patch({
+            Happened: ({ data }, s) => {
+              seen.at = data.at instanceof Date;
+              seen.born = data.born instanceof Date;
+              return { n: s.n + 1 };
+            }
+          }).on({ Do: Happened }).emit((p) => ["Happened", p]).discloses(() => true).build();
+          const t = await over(S);
+          try {
+            await t.app.do(
+              "Do",
+              { stream: t.stream, actor: actor2 },
+              { at: /* @__PURE__ */ new Date(0), born: /* @__PURE__ */ new Date(1) }
+            );
+            await t.cache.clear();
+            await t.app.load(S, { stream: t.stream, actor: actor2 });
+            (0, import_vitest9.expect)(seen).toEqual({ at: true, born: true });
+          } finally {
+            await t.done();
+          }
+        });
+      });
+    });
     (0, import_vitest9.describe)("autoclose end-to-end", () => {
       const Ticket = (0, import_act2.state)({ TckTicket: import_zod2.z.object({ open: import_zod2.z.boolean() }) }).init(() => ({ open: false })).emits({
         TckTicketOpened: import_zod2.z.object({ title: import_zod2.z.string() }),