@pome-sh/checks 0.1.1 → 0.1.3

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # @pome-sh/checks
 
+## 0.1.3
+
+No change to the published surface — `dist/` is byte-identical to 0.1.2, so no
+declaration moved and no consumer's verdict changes. The declaration layer has
+not been touched since 0.1.2 was cut (`38acaf9`), which is the version-bump
+gate doing its job rather than an absence of work.
+
+What this version is for: it is the first release cut by following
+[`RELEASING.md`](../../RELEASING.md) end to end since the `packages-v*` batch
+flow was replaced by version-diff-on-push, and it exists to prove that runbook
+is followable — bump, merge, `release.yml` publishes, pome-cloud pins. The
+consumer half is the part that was actually owed: pome-cloud has been pinned at
+0.1.1 since before 0.1.2 shipped, so F-1157's redaction-survival vocabulary has
+not reached the grader.
+
+Version-only bumps are accepted here rather than carrying an exception list,
+per `cli/CHANGELOG.md` 0.21.7.
+
+## 0.1.2
+
+Carries F-1157 to the grader. Three things move in `dist/`:
+
+- `@pome-sh/checks/dsl` gains `probeRedactionSurvival`, `REDACTION_PLACEHOLDER`
+  and `isRedacted` — the measurement of what protects a criterion whose
+  redaction-destroyed literal is NOT its declared `subject`. `REDACTION_PLACEHOLDER`
+  is the check-side half of a cross-repo contract: the token pome-cloud's state
+  redactor writes is the token these predicates recognise, and it is declared
+  once here rather than spelled twice.
+- `@pome-sh/checks/gmail` — `gmail.mailbox-label-count` answers
+  `mailbox_redacted ("…")` where the mailbox row survived with its address
+  masked, and keeps `mailbox_not_found ("…")` for an export that lists real
+  addresses and not this one. Same `skipped` status either way; only the reason
+  a report renders changes.
+- `@pome-sh/checks/slack` — `slack.no-reaction-added` declares its reaction name
+  as its `subject`, so the engine's redaction-survival arm skips such a
+  criterion at the door instead of letting a masked `reactions[].name` satisfy
+  a negative assertion.
+
 ## 0.1.1
 
 No change to the published surface — `dist/` is byte-identical to 0.1.0, so no

package/dist/_types/sdk/check-redaction.d.ts

@@ -0,0 +1,53 @@
+import type { CheckDefinition } from "./checks.js";
+/**
+ * The token a scoring redactor leaves in place of a value it masked.
+ *
+ * Declared HERE rather than imported from `@pome-sh/wire`, and the distinction
+ * is not pedantic. Wire's redactor scrubs secrets out of a recorded TRACE on the
+ * way to disk; the redactor that eats a check's literal is the consuming
+ * engine's STATE redactor, which runs in pome-cloud against a team's own config.
+ * Two producers, two lifetimes — they agree on the bytes today, and making one
+ * import the other's constant would assert a shared fact neither repo checks.
+ *
+ * So this is the check-side half of that contract, published on
+ * `@pome-sh/checks/dsl` so the engine writing the token and the predicates
+ * recognising it can read it from one place.
+ */
+export declare const REDACTION_PLACEHOLDER = "[REDACTED]";
+/**
+ * Did a redactor eat this value?
+ *
+ * A recogniser, not a proof: a team whose config writes some other placeholder
+ * gets `false` here, and the predicate that asked falls back to whatever it said
+ * before — the status quo, never a wrong verdict. Which is why the vacuous-pass
+ * gate below does not depend on this function at all: it destroys the literal
+ * itself and reads the verdict, so a check that never calls `isRedacted` is
+ * measured exactly as strictly as one that does.
+ */
+export declare function isRedacted(value: string | null | undefined): boolean;
+export type RedactionGuard = "declared_subject" | "vacuous_pass" | "abstains" | "false_fail" | "discriminates_anyway" | "absent_from_world" | "throws";
+export interface RedactionSurvivalRow {
+    readonly param: string;
+    readonly guard: RedactionGuard;
+    readonly detail: string;
+}
+export type RedactionSurvivalVerdict = {
+    kind: "measured";
+    rows: readonly RedactionSurvivalRow[];
+} | {
+    kind: "declined";
+};
+/**
+ * For every slot this check declares, what stands between a redactor that eats
+ * that slot's literal and a vacuous pass.
+ *
+ * The subject arm is credited without evaluating: when the destroyed literal IS
+ * (or is inside) the declared subject, the engine never calls `evaluate`, so
+ * running the predicate anyway would measure a code path production cannot
+ * reach and file its answer under this check's name.
+ *
+ * `includes`, not equality, on that comparison. A subject is usually one arg
+ * verbatim, but a declaration may compose one, and a redactor that masks a
+ * component masks the composed string too.
+ */
+export declare function probeRedactionSurvival<TState, TArgs extends Record<string, string>>(def: CheckDefinition<TState, TArgs>, args: TArgs): RedactionSurvivalVerdict;

package/dist/_types/sdk/checks.d.ts

@@ -91,3 +91,4 @@ export declare function checkNearMissPattern(def: CheckBindingShape): RegExp;
 export declare function parseCheck<TState, TArgs extends Record<string, string>>(def: CheckDefinition<TState, TArgs>, text: string): TArgs | null;
 export { probeDiscrimination } from "./check-discrimination.js";
 export { statePath, childStatePath, resolveStatePath, probeStateCitation, type StateCitationArm, type StateCitationVerdict, } from "./check-state-path.js";
+export { REDACTION_PLACEHOLDER, isRedacted, probeRedactionSurvival, type RedactionGuard, type RedactionSurvivalRow, type RedactionSurvivalVerdict, } from "./check-redaction.js";

package/dist/_types/twin-github/src/seed.d.ts

@@ -61,9 +61,9 @@ export declare const seedSchema: z.ZodObject<{
                 context: z.ZodDefault<z.ZodString>;
                 state: z.ZodDefault<z.ZodEnum<{
                     error: "error";
+                    success: "success";
                     failure: "failure";
                     pending: "pending";
-                    success: "success";
                 }>>;
                 description: z.ZodDefault<z.ZodString>;
             }, z.core.$strip>>>;

package/dist/_types/twin-linear/src/types.d.ts

@@ -4,7 +4,44 @@ export type LinearWorkflowStateType = "backlog" | "unstarted" | "started" | "com
 export type LinearTokenType = "personal" | "oauth_access" | "oauth_refresh" | "client_credentials";
 export type LinearTokenActorType = "user" | "app";
 export type LinearIssuePriority = 0 | 1 | 2 | 3 | 4;
+/** Linear's `AgentActivityType` enum, member-for-member — the `content` discriminator. */
 export type LinearAgentActivityType = "thought" | "elicitation" | "action" | "response" | "error" | "prompt";
+/** Linear's `AgentActivitySignal` enum, member-for-member (F-1176). */
+export type LinearAgentActivitySignal = "stop" | "continue" | "auth" | "select";
+/**
+ * Linear's `AgentActivityContent` union, member-for-member (F-1176).
+ *
+ * Upstream this is a real GraphQL union discriminated on `type`, whose six
+ * members are `AgentActivity{Thought,Action,Response,Elicitation,Error,Prompt}
+ * Content`. Five of the six carry `body`; `action` carries `action` /
+ * `parameter` / `result` instead, which is why an activity's payload cannot be
+ * flattened back to the `{ type, body }` pair the twin used to accept.
+ *
+ * `bodyData` / `resultData` are upstream's structured companions to the text
+ * fields. The twin does not derive them, but it accepts and stores them rather
+ * than refusing an agent that was written against real Linear and sends them.
+ */
+export type LinearAgentActivityContent = {
+    type: "thought" | "response" | "elicitation";
+    body: string;
+    bodyData?: unknown;
+} | {
+    type: "prompt";
+    body: string;
+    title?: string | null;
+    bodyData?: unknown;
+} | {
+    type: "error";
+    body: string;
+    reasonCode?: string | null;
+    bodyData?: unknown;
+} | {
+    type: "action";
+    action: string;
+    parameter: string;
+    result?: string | null;
+    resultData?: unknown;
+};
 /** Linear's `AgentSessionStatus` enum, member-for-member (F-1172). */
 export type LinearAgentSessionStatus = "pending" | "active" | "awaitingInput" | "complete" | "error" | "stale";
 /** One entry of Linear's `AgentSession.externalUrls` JSON payload. */
@@ -208,10 +245,15 @@ export type LinearAgentSession = {
 };
 export type LinearAgentActivity = {
     id: string;
-    sessionId: string;
-    userId: string | null;
-    type: LinearAgentActivityType;
-    body: string;
+    agentSessionId: string;
+    /**
+     * Non-null, matching Linear's `AgentActivity.user: User!`. The column is
+     * still nullable — its FK is `ON DELETE SET NULL` — so this is enforced at
+     * the read boundary, next to the status check, rather than assumed.
+     */
+    userId: string;
+    content: LinearAgentActivityContent;
+    signal: LinearAgentActivitySignal | null;
     ephemeral: boolean;
     createdAt: string;
     updatedAt: string;

package/dist/{chunk-SJ6SVRAA.js → chunk-5PDF3GCK.js}

@@ -1,4 +1,4 @@
-import { oneOf, statePath, defineCheck, VACUITY_SENTINEL, childStatePath } from './chunk-4WXX5VPA.js';
+import { oneOf, statePath, defineCheck, VACUITY_SENTINEL, childStatePath } from './chunk-W2JNYULF.js';
 import { z } from 'zod';
 
 // ../twin-slack/dist/src/check-params.js
@@ -178,7 +178,23 @@ var noReactionAdded = defineCheck({
   params: { reaction: emojiName, channel: channelName },
   substrate: "final",
   polarity: () => "negative",
-  subject: () => null,
+  // The reaction name, because that is the literal this predicate compares
+  // against `reactions[].name` — the line below has said so since the check
+  // shipped, and this field said `null` anyway (F-1157).
+  //
+  // It is the sharpest case in the vocabulary for why that mattered. A NEGATIVE
+  // criterion asserting a scanned literal is absent reads a redactor's work as
+  // its own verdict: mask `reactions[].name` and the filter matches nothing, so
+  // `No "white_check_mark" reaction was added` passes — over an export where the
+  // agent added exactly that reaction. `probeRedactionSurvival` found it by
+  // destroying this literal in the FAILING world declared below and watching
+  // that world start to pass; it was the one `vacuous_pass` across all five
+  // twins' 45 declarations.
+  //
+  // Contrast `slack.no-message-posted` above, whose null is deliberate: its only
+  // literal RESOLVES a channel and the count it asserts on is derived. This one
+  // scans.
+  subject: ({ reaction }) => reaction,
   // The channel RESOLVES (a miss already skips); the reaction name is SCANNED.
   // D10: falsify the scanned one.
   vacuityMutant: (args) => ({ ...args, reaction: VACUITY_SENTINEL }),

package/dist/{chunk-GYFGMULG.js → chunk-SA23X6PB.js}

@@ -1,4 +1,4 @@
-import { statePath, defineCheck, VACUITY_SENTINEL, childStatePath, VACUITY_SENTINEL_NUMBER } from './chunk-4WXX5VPA.js';
+import { statePath, defineCheck, VACUITY_SENTINEL, childStatePath, VACUITY_SENTINEL_NUMBER, isRedacted } from './chunk-W2JNYULF.js';
 import { z } from 'zod';
 
 // ../twin-gmail/dist/src/check-params.js
@@ -437,7 +437,12 @@ var mailboxLabelCount = defineCheck({
       return { passed: false, status: "skipped", reason: "collection_truncated" };
     }
     if (final.mailboxes != null && !final.mailboxes.some((mb) => (mb.email ?? "").toLowerCase() === mailbox.toLowerCase())) {
-      return { passed: false, status: "skipped", reason: `mailbox_not_found ("${mailbox}")` };
+      const eaten = final.mailboxes.some((mb) => isRedacted(mb.email));
+      return {
+        passed: false,
+        status: "skipped",
+        reason: eaten ? `mailbox_redacted ("${mailbox}")` : `mailbox_not_found ("${mailbox}")`
+      };
     }
     const ids = labelIdsFor(final, label);
     const labeled = new Set(final.messageLabels.filter((row) => ids.has((row.labelId ?? "").toLowerCase())).map((row) => (row.messageId ?? "").toLowerCase()));

package/dist/{chunk-NORTPYDQ.js → chunk-THOSO63W.js}

@@ -1,4 +1,4 @@
-import { statePath, defineCheck, VACUITY_SENTINEL, VACUITY_SENTINEL_NUMBER, childStatePath } from './chunk-4WXX5VPA.js';
+import { statePath, defineCheck, VACUITY_SENTINEL, VACUITY_SENTINEL_NUMBER, childStatePath } from './chunk-W2JNYULF.js';
 import { z } from 'zod';
 
 // ../twin-linear/dist/src/check-params.js

package/dist/{chunk-5SJ4PVO5.js → chunk-UCV6YLN2.js}

@@ -1,4 +1,4 @@
-import { oneOf, defineCheck, repoRef, VACUITY_SENTINEL_NUMBER, childStatePath, VACUITY_SENTINEL, statePath } from './chunk-4WXX5VPA.js';
+import { oneOf, defineCheck, repoRef, VACUITY_SENTINEL_NUMBER, childStatePath, VACUITY_SENTINEL, statePath } from './chunk-W2JNYULF.js';
 import { z } from 'zod';
 
 // ../twin-github/dist/src/tape-assertable-tools.js

package/dist/{chunk-4WXX5VPA.js → chunk-W2JNYULF.js}

@@ -120,6 +120,103 @@ function probeStateCitation(def, args) {
     return passing;
   return probeArm(def, args, "failing", worlds.failing);
 }
+
+// ../sdk/dist/check-redaction.js
+var REDACTION_PLACEHOLDER = "[REDACTED]";
+function isRedacted(value) {
+  return value === REDACTION_PLACEHOLDER;
+}
+function destroyLiteral(tree, literal) {
+  const wanted = literal.toLowerCase();
+  let hit = false;
+  const walk = (node) => {
+    if (typeof node === "string") {
+      if (node.toLowerCase() !== wanted)
+        return node;
+      hit = true;
+      return REDACTION_PLACEHOLDER;
+    }
+    if (Array.isArray(node))
+      return node.map(walk);
+    if (node === null || typeof node !== "object")
+      return node;
+    return Object.fromEntries(Object.entries(node).map(([key, value]) => [key, walk(value)]));
+  };
+  return { tree: walk(tree), hit };
+}
+function destroyWorld(world, literal) {
+  const seed = destroyLiteral(world.seed, literal);
+  const final = destroyLiteral(world.final, literal);
+  const tape = destroyLiteral(world.tape, literal);
+  return {
+    world: {
+      seed: seed.tree,
+      final: final.tree,
+      tape: tape.tree
+    },
+    hit: seed.hit || final.hit || tape.hit
+  };
+}
+var describeOutcome2 = (outcome) => `passed=${outcome.passed} status=${outcome.status ?? "-"} reason=${JSON.stringify(outcome.reason)}`;
+function say(evaluate) {
+  try {
+    return evaluate();
+  } catch (error) {
+    return { threw: error instanceof Error ? error.message : String(error) };
+  }
+}
+var isRealPass2 = (outcome) => outcome.passed === true && (outcome.status === void 0 || outcome.status === "passed");
+function classify(passing, failing) {
+  if ("threw" in passing)
+    return { guard: "throws", detail: `passing world: ${passing.threw}` };
+  if ("threw" in failing)
+    return { guard: "throws", detail: `failing world: ${failing.threw}` };
+  if (isRealPass2(failing)) {
+    return { guard: "vacuous_pass", detail: `failing world now passes \u2014 ${describeOutcome2(failing)}` };
+  }
+  if (passing.status === "skipped") {
+    return { guard: "abstains", detail: describeOutcome2(passing) };
+  }
+  if (isRealPass2(passing)) {
+    return { guard: "discriminates_anyway", detail: describeOutcome2(passing) };
+  }
+  return { guard: "false_fail", detail: `passing world now fails \u2014 ${describeOutcome2(passing)}` };
+}
+function probeRedactionSurvival(def, args) {
+  const worlds = def.discriminatingWorlds(args);
+  if (worlds === null)
+    return { kind: "declined" };
+  const subject = def.subject?.(args) ?? null;
+  const rows = [];
+  for (const param of Object.keys(def.params)) {
+    const literal = args[param];
+    if (typeof literal !== "string" || literal === "")
+      continue;
+    if (subject !== null && subject.toLowerCase().includes(literal.toLowerCase())) {
+      rows.push({
+        param,
+        guard: "declared_subject",
+        detail: `the engine skips the criterion before evaluate \u2014 subject ${JSON.stringify(subject)}`
+      });
+      continue;
+    }
+    const passing = destroyWorld(worlds.passing, literal);
+    const failing = destroyWorld(worlds.failing, literal);
+    if (!passing.hit && !failing.hit) {
+      rows.push({
+        param,
+        guard: "absent_from_world",
+        detail: `${JSON.stringify(literal)} appears in neither declared world`
+      });
+      continue;
+    }
+    rows.push({
+      param,
+      ...classify(say(() => def.evaluate(args, passing.world)), say(() => def.evaluate(args, failing.world)))
+    });
+  }
+  return { kind: "measured", rows };
+}
 var VACUITY_SENTINEL = "pome-vacuity-never";
 var VACUITY_SENTINEL_SNAKE = "pome_vacuity_never";
 var VACUITY_SENTINEL_NUMBER = 987654321;
@@ -235,4 +332,4 @@ function parseCheck(def, text) {
   return args;
 }
 
-export { VACUITY_SENTINEL, VACUITY_SENTINEL_NUMBER, VACUITY_SENTINEL_SNAKE, checkNearMissPattern, checkPattern, checksDigest, childStatePath, defineCheck, oneOf, parseCheck, probeDiscrimination, probeStateCitation, renderCheck, repoRef, resolveStatePath, statePath, templateSlots };
+export { REDACTION_PLACEHOLDER, VACUITY_SENTINEL, VACUITY_SENTINEL_NUMBER, VACUITY_SENTINEL_SNAKE, checkNearMissPattern, checkPattern, checksDigest, childStatePath, defineCheck, isRedacted, oneOf, parseCheck, probeDiscrimination, probeRedactionSurvival, probeStateCitation, renderCheck, repoRef, resolveStatePath, statePath, templateSlots };

package/dist/{chunk-IVENH4KX.js → chunk-XOUAZPNB.js}

@@ -1,4 +1,4 @@
-import { oneOf, statePath, defineCheck, VACUITY_SENTINEL_NUMBER, VACUITY_SENTINEL, childStatePath } from './chunk-4WXX5VPA.js';
+import { oneOf, statePath, defineCheck, VACUITY_SENTINEL_NUMBER, VACUITY_SENTINEL, childStatePath } from './chunk-W2JNYULF.js';
 import { z } from 'zod';
 
 // ../twin-stripe/dist/src/check-params.js

package/dist/dsl.js

@@ -1,2 +1,2 @@
 import './chunk-ZXE6LAM3.js';
-export { VACUITY_SENTINEL, VACUITY_SENTINEL_NUMBER, VACUITY_SENTINEL_SNAKE, checkNearMissPattern, checkPattern, checksDigest, childStatePath, defineCheck, oneOf, parseCheck, probeDiscrimination, probeStateCitation, renderCheck, repoRef, resolveStatePath, statePath, templateSlots } from './chunk-4WXX5VPA.js';
+export { REDACTION_PLACEHOLDER, VACUITY_SENTINEL, VACUITY_SENTINEL_NUMBER, VACUITY_SENTINEL_SNAKE, checkNearMissPattern, checkPattern, checksDigest, childStatePath, defineCheck, isRedacted, oneOf, parseCheck, probeDiscrimination, probeRedactionSurvival, probeStateCitation, renderCheck, repoRef, resolveStatePath, statePath, templateSlots } from './chunk-W2JNYULF.js';

package/dist/github.js

@@ -1,2 +1,2 @@
-export { GITHUB_CHECKS, defaultSeedState, parseSeed, seedSchema } from './chunk-5SJ4PVO5.js';
-import './chunk-4WXX5VPA.js';
+export { GITHUB_CHECKS, defaultSeedState, parseSeed, seedSchema } from './chunk-UCV6YLN2.js';
+import './chunk-W2JNYULF.js';

package/dist/gmail.js

@@ -1,2 +1,2 @@
-export { GMAIL_CHECKS, defaultSeedState, gmailSeedSchema, parseSeed } from './chunk-GYFGMULG.js';
-import './chunk-4WXX5VPA.js';
+export { GMAIL_CHECKS, defaultSeedState, gmailSeedSchema, parseSeed } from './chunk-SA23X6PB.js';
+import './chunk-W2JNYULF.js';

package/dist/index.js

@@ -1,15 +1,15 @@
 import './chunk-ZXE6LAM3.js';
-import { GITHUB_CHECKS } from './chunk-5SJ4PVO5.js';
-export { GITHUB_CHECKS, defaultSeedState as defaultGitHubSeed, seedSchema as githubSeedSchema, parseSeed as parseGitHubSeed } from './chunk-5SJ4PVO5.js';
-import { GMAIL_CHECKS } from './chunk-GYFGMULG.js';
-export { GMAIL_CHECKS, defaultSeedState as defaultGmailSeed, gmailSeedSchema, parseSeed as parseGmailSeed } from './chunk-GYFGMULG.js';
-import { LINEAR_CHECKS } from './chunk-NORTPYDQ.js';
-export { LINEAR_CHECKS, defaultSeedState as defaultLinearSeed, linearSeedSchema, parseSeed as parseLinearSeed } from './chunk-NORTPYDQ.js';
-import { SLACK_CHECKS } from './chunk-SJ6SVRAA.js';
-export { SLACK_CHECKS, defaultSeedState as defaultSlackSeed, parseSeed as parseSlackSeed, seedSchema as slackSeedSchema } from './chunk-SJ6SVRAA.js';
-import { STRIPE_CHECKS } from './chunk-IVENH4KX.js';
-export { STRIPE_CHECKS, defaultSeed as defaultStripeSeed, parseSeed as parseStripeSeed, seedSchema as stripeSeedSchema } from './chunk-IVENH4KX.js';
-export { VACUITY_SENTINEL, VACUITY_SENTINEL_NUMBER, VACUITY_SENTINEL_SNAKE, checkNearMissPattern, checkPattern, checksDigest, childStatePath, defineCheck, oneOf, parseCheck, probeDiscrimination, probeStateCitation, renderCheck, repoRef, resolveStatePath, statePath, templateSlots } from './chunk-4WXX5VPA.js';
+import { GITHUB_CHECKS } from './chunk-UCV6YLN2.js';
+export { GITHUB_CHECKS, defaultSeedState as defaultGitHubSeed, seedSchema as githubSeedSchema, parseSeed as parseGitHubSeed } from './chunk-UCV6YLN2.js';
+import { GMAIL_CHECKS } from './chunk-SA23X6PB.js';
+export { GMAIL_CHECKS, defaultSeedState as defaultGmailSeed, gmailSeedSchema, parseSeed as parseGmailSeed } from './chunk-SA23X6PB.js';
+import { LINEAR_CHECKS } from './chunk-THOSO63W.js';
+export { LINEAR_CHECKS, defaultSeedState as defaultLinearSeed, linearSeedSchema, parseSeed as parseLinearSeed } from './chunk-THOSO63W.js';
+import { SLACK_CHECKS } from './chunk-5PDF3GCK.js';
+export { SLACK_CHECKS, defaultSeedState as defaultSlackSeed, parseSeed as parseSlackSeed, seedSchema as slackSeedSchema } from './chunk-5PDF3GCK.js';
+import { STRIPE_CHECKS } from './chunk-XOUAZPNB.js';
+export { STRIPE_CHECKS, defaultSeed as defaultStripeSeed, parseSeed as parseStripeSeed, seedSchema as stripeSeedSchema } from './chunk-XOUAZPNB.js';
+export { REDACTION_PLACEHOLDER, VACUITY_SENTINEL, VACUITY_SENTINEL_NUMBER, VACUITY_SENTINEL_SNAKE, checkNearMissPattern, checkPattern, checksDigest, childStatePath, defineCheck, isRedacted, oneOf, parseCheck, probeDiscrimination, probeRedactionSurvival, probeStateCitation, renderCheck, repoRef, resolveStatePath, statePath, templateSlots } from './chunk-W2JNYULF.js';
 
 // src/index.ts
 var CHECKS_TWIN_NAMES = ["github", "slack", "stripe", "gmail", "linear"];

package/dist/linear.js

@@ -1,2 +1,2 @@
-export { LINEAR_CHECKS, defaultSeedState, linearSeedSchema, parseSeed } from './chunk-NORTPYDQ.js';
-import './chunk-4WXX5VPA.js';
+export { LINEAR_CHECKS, defaultSeedState, linearSeedSchema, parseSeed } from './chunk-THOSO63W.js';
+import './chunk-W2JNYULF.js';

package/dist/slack.js

@@ -1,2 +1,2 @@
-export { SLACK_CHECKS, defaultSeedState, parseSeed, seedSchema } from './chunk-SJ6SVRAA.js';
-import './chunk-4WXX5VPA.js';
+export { SLACK_CHECKS, defaultSeedState, parseSeed, seedSchema } from './chunk-5PDF3GCK.js';
+import './chunk-W2JNYULF.js';

package/dist/stripe.js

@@ -1,2 +1,2 @@
-export { STRIPE_CHECKS, defaultSeed, parseSeed, seedSchema } from './chunk-IVENH4KX.js';
-import './chunk-4WXX5VPA.js';
+export { STRIPE_CHECKS, defaultSeed, parseSeed, seedSchema } from './chunk-XOUAZPNB.js';
+import './chunk-W2JNYULF.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pome-sh/checks",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Pome's grading vocabulary — the check declarations, seed schemas and default seeds of all five digital twins, plus the check DSL they are written in. Declarations only: no twin server, no database, no routes, no tools.",
   "private": false,
   "type": "module",