@substrat-run/contracts 0.138.0 → 0.140.0

package/dist/email-intent.js

@@ -0,0 +1,111 @@
+import { z } from 'zod';
+import { EMAIL_RELAY_MAX_ATTACHMENTS } from './control-plane.js';
+import { entityRef } from './events.js';
+import { dataSubjectId, platformRequestId } from './ids.js';
+/**
+ * Email as a transactional platform intent (#2102).
+ *
+ * A vertical's mail used to be a synchronous POST to the control plane's email relay, made
+ * outside the operation's transaction: an operation that threw after the call had still sent
+ * the mail, and a send that failed was simply lost. Requested as an intent instead, the send
+ * is a row in the scope's own spine written by the operation — so it commits or rolls back
+ * with everything else the operation did — and the platform's drain delivers it afterwards,
+ * retrying what a provider deferred and saying what became of it as an event.
+ *
+ * The payload is the relay's body without the caller's identity: the drain reads the row out
+ * of the scope that wrote it, so who is asking is never something the payload says.
+ */
+export const SEND_EMAIL_KIND = 'send-email';
+export const sendEmailRequest = z
+    .object({
+    to: z.string().email(),
+    subject: z.string().min(1),
+    html: z.string().min(1),
+    text: z.string().min(1),
+    /** The display name for the FROM. With no `from`, the address stays the platform's. */
+    fromName: z.string().min(1).optional(),
+    /** Send as this tenant address, through the tenant's mail connection that covers it (#2098). */
+    from: z.string().email().optional(),
+    /** Files from the sending scope, by attachment id. Only with `from`. */
+    attachments: z
+        .array(z.object({ attachmentId: z.string().min(1) }).strict())
+        .max(EMAIL_RELAY_MAX_ATTACHMENTS)
+        .optional(),
+    /**
+     * The entity this mail is about — an invoice, a ticket. The outcome event is written on
+     * that entity, so its timeline says the mail went (or did not). Absent, the event is
+     * written on the intent itself (`{ entityType: 'platform-request', entityId: <id> }`).
+     */
+    about: entityRef.optional(),
+    /**
+     * The person this mail is to or about, when it is one. The row holds their address and the
+     * message, so it is personal data in the spine, and this id is what a subject erasure finds
+     * it by: a held send is cancelled and the row becomes a tombstone, as an event copy does.
+     * Without it, nothing links the row to anybody (kernel-design.md §13.1, limit 7).
+     */
+    subjectId: dataSubjectId.optional(),
+    /**
+     * Stamped by `requestEmail` beside `subjectId` — never needed from module code. With
+     * `subjectId` it is the outbox's own erasure predicate (`subjectId` + a `piiClass` other
+     * than `none`), which the intent redaction already applies to every payload it walks.
+     */
+    piiClass: z.literal('direct').optional(),
+})
+    .strict()
+    .refine((m) => m.piiClass === undefined || m.subjectId !== undefined, {
+    message: '`piiClass` classifies a `subjectId`; there is none',
+    path: ['piiClass'],
+})
+    .refine((m) => !m.attachments?.length || m.from !== undefined, {
+    message: "attachments ride only with `from` — the platform's own sender carries none",
+    path: ['attachments'],
+});
+/** The entity type an outcome is written on when the request named none. */
+export const PLATFORM_REQUEST_ENTITY_TYPE = 'platform-request';
+/** The provider accepted the message. Not delivery to an inbox: "accepted" is all most say. */
+export const EMAIL_SENT = 'email.sent';
+/** The provider, or the platform on its behalf, refused the message for good. Not retried. */
+export const EMAIL_REFUSED = 'email.refused';
+/** Every attempt the platform allows met a transient failure. The send is over. */
+export const EMAIL_DEAD_LETTERED = 'email.dead-lettered';
+export const emailOutcomeType = z.enum([EMAIL_SENT, EMAIL_REFUSED, EMAIL_DEAD_LETTERED]);
+/**
+ * The outcome event's payload. Deliberately carries no address and no provider prose: an
+ * event is retained beyond the person it would name, and a provider's refusal can quote
+ * them. The full refusal stays on the intent row (`ctx.platformRequests`), which erasure
+ * reaches; the event says which request, what happened, and the codes a screen branches on.
+ */
+export const emailOutcomePayload = z
+    .object({
+    /** The id `requestEmail` returned — how a vertical joins the event to what it asked. */
+    request: platformRequestId,
+    about: entityRef.nullable(),
+    /** Whose sender carried it: the platform's own address, or a tenant connection's. */
+    sender: z.enum(['platform', 'tenant']),
+    /** The provider's id for the message, when the provider gives one. */
+    messageId: z.string().min(1).nullable(),
+    /** Attempts made, this one included. */
+    attempts: z.number().int().positive(),
+    /** The taxonomy code of a refusal or of the last transient failure; `null` on `email.sent`. */
+    code: z.string().min(1).nullable(),
+    /** The provider's HTTP status, when the failure carried one. */
+    status: z.number().int().nullable(),
+})
+    .strict();
+/**
+ * An event a platform-request SETTLE writes into the scope (#2102) — the drain's way of saying
+ * what became of an intent as a fact the vertical can consume, rather than a row it must poll.
+ *
+ * The drain names the type, the entity and the payload; the scope stamps the rest (id, time,
+ * tenant, scope, the kernel as actor) and writes it in the same transaction as the settle, and
+ * only when that settle moved the row out of `pending`. A type outside this enum is refused,
+ * so the settle route cannot be used to write an arbitrary event into a scope.
+ */
+export const platformOutcomeEvent = z
+    .object({
+    type: emailOutcomeType,
+    entity: entityRef,
+    payload: emailOutcomePayload,
+})
+    .strict();
+//# sourceMappingURL=email-intent.js.map

package/dist/email-intent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"email-intent.js","sourceRoot":"","sources":["../src/email-intent.ts"],"names":[],"mappings":"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"}

package/dist/entity-state.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Entity archive and trash (#119) — the vocabulary the kernel and a module share.
+ *
+ * Three different acts get habitually conflated, and only one of them lives here:
+ *
+ * - **Subject erasure** (#37, K-37) removes a person's data from everywhere the platform can
+ *   reach, history included. Not reversible, and not about an entity.
+ * - **Tenant delete and retention** (#36) removes a whole tenant after a grace window. Not
+ *   about an entity either.
+ * - **Archive and trash** — this — hide ONE entity from active views and keep it. Both are
+ *   reversible, both keep the row, and neither touches history: the events about the entity
+ *   stay exactly as they were.
+ *
+ * Archive and trash are deliberately two acts with two permission keys. Archive says "done
+ * with this, keep it": the row stays readable through the entity's ordinary read authority.
+ * Trash says "I meant to delete this": the row stays recoverable, but only someone holding
+ * the declared trash key can see it or bring it back.
+ *
+ * ## The state is two columns, and the visible state is derived from them
+ *
+ * An entity that declares either one gets kernel-owned columns on its own table,
+ * `_substrat_archived_at` and `_substrat_trashed_at`. Stored apart rather than as one enum,
+ * so trash never forgets an archive: trashing an archived row and restoring it brings it back
+ * archived, never silently into the active view. What a reader sees is one state, derived:
+ *
+ *     trashed   when `_substrat_trashed_at` is set
+ *     archived  else when `_substrat_archived_at` is set
+ *     active    otherwise
+ */
+import { z } from 'zod';
+/** The state an archivable or trashable entity is in, as a reader sees it. */
+export declare const entityStateName: z.ZodEnum<{
+    active: "active";
+    archived: "archived";
+    trashed: "trashed";
+}>;
+export type EntityStateName = z.infer<typeof entityStateName>;
+/** The kernel-owned column that records an archive. */
+export declare const ARCHIVED_AT_COLUMN = "_substrat_archived_at";
+/** The kernel-owned column that records a trash. */
+export declare const TRASHED_AT_COLUMN = "_substrat_trashed_at";
+/**
+ * One entity's declaration, as the manifest carries it.
+ *
+ * Written into a model as `archive: { permission }` / `trash: { permission }` on the entity
+ * (`defineEntities`); `manifestEntities()` turns that into this and fills in `table` and
+ * `idColumn` from the registry, as it does for `searchables`. A hand-written manifest (an
+ * engine's) may declare it directly.
+ *
+ * `archivePermission` gates `ctx.archive` and `ctx.unarchive`; `trashPermission` gates
+ * `ctx.trash`, `ctx.restore` and the trashed readers. At least one is required. A key here
+ * must be one the module declares.
+ */
+export declare const entityStateDeclaration: z.ZodObject<{
+    entityType: z.ZodString;
+    archivePermission: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "PermissionKey", "out">>;
+    trashPermission: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "PermissionKey", "out">>;
+    purgeAfterDays: z.ZodOptional<z.ZodNumber>;
+    table: z.ZodOptional<z.ZodString>;
+    idColumn: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type EntityStateDeclaration = z.infer<typeof entityStateDeclaration>;
+/** `ctx.archive` moved an entity out of the active view. Entity: the entity. */
+export declare const ENTITY_ARCHIVED = "entity.archived";
+/** `ctx.unarchive` brought an archived entity back. Entity: the entity. */
+export declare const ENTITY_UNARCHIVED = "entity.unarchived";
+/** `ctx.trash` moved an entity into the trash. Entity: the entity. */
+export declare const ENTITY_TRASHED = "entity.trashed";
+/** `ctx.restore` took an entity out of the trash, back to the state it was trashed from. */
+export declare const ENTITY_RESTORED = "entity.restored";
+/**
+ * The one payload all four carry: the entity, and the visible state before and after.
+ *
+ * Who did it and when are not here — they are the envelope's actor and `occurredAt`, stamped
+ * by the kernel, with the K-34 authorization chain beside them. `from` and `to` are the
+ * derived states, so `entity.restored` says where the entity went back to (`active` or
+ * `archived`) without the reader having to replay anything.
+ */
+export declare const entityStateChangedPayload: z.ZodObject<{
+    entity: z.ZodObject<{
+        entityType: z.ZodString;
+        entityId: z.ZodString;
+    }, z.core.$strip>;
+    from: z.ZodEnum<{
+        active: "active";
+        archived: "archived";
+        trashed: "trashed";
+    }>;
+    to: z.ZodEnum<{
+        active: "active";
+        archived: "archived";
+        trashed: "trashed";
+    }>;
+}, z.core.$strip>;
+export type EntityStateChangedPayload = z.infer<typeof entityStateChangedPayload>;
+//# sourceMappingURL=entity-state.d.ts.map

package/dist/entity-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-state.d.ts","sourceRoot":"","sources":["../src/entity-state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,8EAA8E;AAC9E,eAAO,MAAM,eAAe;;;;EAA4C,CAAC;AACzE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,uDAAuD;AACvD,eAAO,MAAM,kBAAkB,0BAA0B,CAAC;AAC1D,oDAAoD;AACpD,eAAO,MAAM,iBAAiB,yBAAyB,CAAC;AAExD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,sBAAsB;;;;;;;iBAYjC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE5E,gFAAgF;AAChF,eAAO,MAAM,eAAe,oBAAoB,CAAC;AACjD,2EAA2E;AAC3E,eAAO,MAAM,iBAAiB,sBAAsB,CAAC;AACrD,sEAAsE;AACtE,eAAO,MAAM,cAAc,mBAAmB,CAAC;AAC/C,4FAA4F;AAC5F,eAAO,MAAM,eAAe,oBAAoB,CAAC;AAEjD;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;iBAIpC,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

package/dist/entity-state.js

@@ -0,0 +1,85 @@
+/**
+ * Entity archive and trash (#119) — the vocabulary the kernel and a module share.
+ *
+ * Three different acts get habitually conflated, and only one of them lives here:
+ *
+ * - **Subject erasure** (#37, K-37) removes a person's data from everywhere the platform can
+ *   reach, history included. Not reversible, and not about an entity.
+ * - **Tenant delete and retention** (#36) removes a whole tenant after a grace window. Not
+ *   about an entity either.
+ * - **Archive and trash** — this — hide ONE entity from active views and keep it. Both are
+ *   reversible, both keep the row, and neither touches history: the events about the entity
+ *   stay exactly as they were.
+ *
+ * Archive and trash are deliberately two acts with two permission keys. Archive says "done
+ * with this, keep it": the row stays readable through the entity's ordinary read authority.
+ * Trash says "I meant to delete this": the row stays recoverable, but only someone holding
+ * the declared trash key can see it or bring it back.
+ *
+ * ## The state is two columns, and the visible state is derived from them
+ *
+ * An entity that declares either one gets kernel-owned columns on its own table,
+ * `_substrat_archived_at` and `_substrat_trashed_at`. Stored apart rather than as one enum,
+ * so trash never forgets an archive: trashing an archived row and restoring it brings it back
+ * archived, never silently into the active view. What a reader sees is one state, derived:
+ *
+ *     trashed   when `_substrat_trashed_at` is set
+ *     archived  else when `_substrat_archived_at` is set
+ *     active    otherwise
+ */
+import { z } from 'zod';
+import { entityRef } from './events.js';
+import { permissionKey } from './ids.js';
+/** The state an archivable or trashable entity is in, as a reader sees it. */
+export const entityStateName = z.enum(['active', 'archived', 'trashed']);
+/** The kernel-owned column that records an archive. */
+export const ARCHIVED_AT_COLUMN = '_substrat_archived_at';
+/** The kernel-owned column that records a trash. */
+export const TRASHED_AT_COLUMN = '_substrat_trashed_at';
+/**
+ * One entity's declaration, as the manifest carries it.
+ *
+ * Written into a model as `archive: { permission }` / `trash: { permission }` on the entity
+ * (`defineEntities`); `manifestEntities()` turns that into this and fills in `table` and
+ * `idColumn` from the registry, as it does for `searchables`. A hand-written manifest (an
+ * engine's) may declare it directly.
+ *
+ * `archivePermission` gates `ctx.archive` and `ctx.unarchive`; `trashPermission` gates
+ * `ctx.trash`, `ctx.restore` and the trashed readers. At least one is required. A key here
+ * must be one the module declares.
+ */
+export const entityStateDeclaration = z.object({
+    entityType: z.string().min(1),
+    archivePermission: permissionKey.optional(),
+    trashPermission: permissionKey.optional(),
+    /**
+     * The purge horizon (#119): an entity trashed longer than this many days is permanently
+     * deleted by the platform's sweep, through the module's own `trashed: 'purges'` operation
+     * (run as a derived schedule — `purgeSchedulesOf`). Requires `trashPermission`.
+     */
+    purgeAfterDays: z.number().int().positive().optional(),
+    table: z.string().min(1).optional(),
+    idColumn: z.string().min(1).optional(),
+});
+/** `ctx.archive` moved an entity out of the active view. Entity: the entity. */
+export const ENTITY_ARCHIVED = 'entity.archived';
+/** `ctx.unarchive` brought an archived entity back. Entity: the entity. */
+export const ENTITY_UNARCHIVED = 'entity.unarchived';
+/** `ctx.trash` moved an entity into the trash. Entity: the entity. */
+export const ENTITY_TRASHED = 'entity.trashed';
+/** `ctx.restore` took an entity out of the trash, back to the state it was trashed from. */
+export const ENTITY_RESTORED = 'entity.restored';
+/**
+ * The one payload all four carry: the entity, and the visible state before and after.
+ *
+ * Who did it and when are not here — they are the envelope's actor and `occurredAt`, stamped
+ * by the kernel, with the K-34 authorization chain beside them. `from` and `to` are the
+ * derived states, so `entity.restored` says where the entity went back to (`active` or
+ * `archived`) without the reader having to replay anything.
+ */
+export const entityStateChangedPayload = z.object({
+    entity: entityRef,
+    from: entityStateName,
+    to: entityStateName,
+});
+//# sourceMappingURL=entity-state.js.map

package/dist/entity-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-state.js","sourceRoot":"","sources":["../src/entity-state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,8EAA8E;AAC9E,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC,CAAC;AAGzE,uDAAuD;AACvD,MAAM,CAAC,MAAM,kBAAkB,GAAG,uBAAuB,CAAC;AAC1D,oDAAoD;AACpD,MAAM,CAAC,MAAM,iBAAiB,GAAG,sBAAsB,CAAC;AAExD;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC7C,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC7B,iBAAiB,EAAE,aAAa,CAAC,QAAQ,EAAE;IAC3C,eAAe,EAAE,aAAa,CAAC,QAAQ,EAAE;IACzC;;;;OAIG;IACH,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;IACtD,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;IACnC,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;CACvC,CAAC,CAAC;AAGH,gFAAgF;AAChF,MAAM,CAAC,MAAM,eAAe,GAAG,iBAAiB,CAAC;AACjD,2EAA2E;AAC3E,MAAM,CAAC,MAAM,iBAAiB,GAAG,mBAAmB,CAAC;AACrD,sEAAsE;AACtE,MAAM,CAAC,MAAM,cAAc,GAAG,gBAAgB,CAAC;AAC/C,4FAA4F;AAC5F,MAAM,CAAC,MAAM,eAAe,GAAG,iBAAiB,CAAC;AAEjD;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAAC;IAChD,MAAM,EAAE,SAAS;IACjB,IAAI,EAAE,eAAe;IACrB,EAAE,EAAE,eAAe;CACpB,CAAC,CAAC"}

package/dist/findings.d.ts

@@ -0,0 +1,208 @@
+import { z } from 'zod';
+import { tenantId } from './ids.js';
+/**
+ * Findings (#1748): anomalies a tenant triages like email, in one inbox with one lifecycle.
+ *
+ * - `invariant`: a rule was broken — expected 0, observed N (a scheduled run that failed).
+ * - `drift`: unusual against an expectation — a freshness expectation gone stale.
+ * - `recurring`: one failure shape, seen again and again — the tenant's own projection of an
+ *   `_substrat_issues` fingerprint (#1233), counted over that tenant's occurrences only.
+ *
+ * A finding is TENANT-scoped by construction: its counters, versions and evidence come from
+ * that tenant's own rows, so the fleet aggregate it shares a fingerprint with is never visible
+ * through it. It carries no free text from the evidence (no message, no upstream reference):
+ * the evidence ref names where the rows are, and the reader reads them through its own
+ * tenant-forced view.
+ */
+export declare const findingKind: z.ZodEnum<{
+    drift: "drift";
+    invariant: "invariant";
+    recurring: "recurring";
+}>;
+export type FindingKind = z.infer<typeof findingKind>;
+/**
+ * The lifecycle. `_substrat_issues` maps onto it 1:1 — new → `open`, regressed → `open` with
+ * `regressed`, resolved → `resolved`, ignored → `suppressed` — and `acked` is the one state an
+ * issue has no word for: "somebody is on it".
+ */
+export declare const findingStatus: z.ZodEnum<{
+    acked: "acked";
+    open: "open";
+    resolved: "resolved";
+    suppressed: "suppressed";
+}>;
+export type FindingStatus = z.infer<typeof findingStatus>;
+/**
+ * What a verdict may SET. `suppressed` is never set directly: it is what a suppress RULE does,
+ * because a suppression without a scope and an expiry is a finding nobody will ever see again.
+ */
+export declare const findingStatusInput: z.ZodEnum<{
+    acked: "acked";
+    open: "open";
+    resolved: "resolved";
+}>;
+export type FindingStatusInput = z.infer<typeof findingStatusInput>;
+export declare const findingSeverity: z.ZodEnum<{
+    critical: "critical";
+    info: "info";
+    warning: "warning";
+}>;
+export type FindingSeverity = z.infer<typeof findingSeverity>;
+/** Where the occurrences behind a finding are read: the reader's own tenant-forced view of them. */
+export declare const findingEvidence: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    source: z.ZodLiteral<"ops-failures">;
+    fingerprint: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    source: z.ZodLiteral<"sweep-runs">;
+    kind: z.ZodEnum<{
+        freshness: "freshness";
+        schedule: "schedule";
+    }>;
+    unit: z.ZodString;
+}, z.core.$strip>], "source">;
+export type FindingEvidence = z.infer<typeof findingEvidence>;
+/**
+ * Why the finding is believed to have started, with the reason stated. Only `deploy` today: a
+ * finding that comes back under a version other than the one it was resolved under names the
+ * new version. Nothing is claimed when nothing changed — no cause is better than an invented one.
+ */
+export declare const findingLikelyCause: z.ZodObject<{
+    kind: z.ZodLiteral<"deploy">;
+    version: z.ZodString;
+    reason: z.ZodString;
+}, z.core.$strip>;
+export type FindingLikelyCause = z.infer<typeof findingLikelyCause>;
+export declare const findingEntry: z.ZodObject<{
+    id: z.ZodString;
+    tenantId: z.core.$ZodBranded<z.ZodString, "TenantId", "out">;
+    kind: z.ZodEnum<{
+        drift: "drift";
+        invariant: "invariant";
+        recurring: "recurring";
+    }>;
+    subject: z.ZodString;
+    status: z.ZodEnum<{
+        acked: "acked";
+        open: "open";
+        resolved: "resolved";
+        suppressed: "suppressed";
+    }>;
+    regressed: z.ZodBoolean;
+    severity: z.ZodEnum<{
+        critical: "critical";
+        info: "info";
+        warning: "warning";
+    }>;
+    title: z.ZodString;
+    operation: z.ZodNullable<z.ZodString>;
+    codes: z.ZodArray<z.ZodEnum<{
+        conflict: "conflict";
+        forbidden: "forbidden";
+        internal: "internal";
+        not_found: "not_found";
+        permission_denied: "permission_denied";
+        precondition_failed: "precondition_failed";
+        rate_limited: "rate_limited";
+        unauthenticated: "unauthenticated";
+        unavailable: "unavailable";
+        validation_failed: "validation_failed";
+    }>>;
+    vertical: z.ZodNullable<z.ZodString>;
+    scopeId: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "ScopeId", "out">>;
+    count: z.ZodNumber;
+    firstSeen: z.core.$ZodBranded<z.ZodString, "Instant", "out">;
+    lastSeen: z.core.$ZodBranded<z.ZodString, "Instant", "out">;
+    lastVersion: z.ZodNullable<z.ZodString>;
+    resolvedVersion: z.ZodNullable<z.ZodString>;
+    resolvedAt: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "Instant", "out">>;
+    resolution: z.ZodNullable<z.ZodEnum<{
+        stale: "stale";
+        verdict: "verdict";
+    }>>;
+    acknowledgedAt: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "Instant", "out">>;
+    ruleId: z.ZodNullable<z.ZodString>;
+    evidence: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        source: z.ZodLiteral<"ops-failures">;
+        fingerprint: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        source: z.ZodLiteral<"sweep-runs">;
+        kind: z.ZodEnum<{
+            freshness: "freshness";
+            schedule: "schedule";
+        }>;
+        unit: z.ZodString;
+    }, z.core.$strip>], "source">;
+    likelyCause: z.ZodNullable<z.ZodObject<{
+        kind: z.ZodLiteral<"deploy">;
+        version: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type FindingEntry = z.infer<typeof findingEntry>;
+/** The longest a suppression may last. A permanent "never show me this" is not a rule; it is a blind spot. */
+export declare const FINDING_RULE_MAX_DAYS = 90;
+/**
+ * A suppress rule (#1748): a scope plus an expiry. A matching occurrence is still COUNTED on its
+ * finding, but the finding stays `suppressed` instead of opening. Each set field narrows; at
+ * least one must be set, so a rule never silences a whole tenant.
+ */
+export declare const findingRuleInput: z.ZodObject<{
+    kind: z.ZodOptional<z.ZodEnum<{
+        drift: "drift";
+        invariant: "invariant";
+        recurring: "recurring";
+    }>>;
+    operation: z.ZodOptional<z.ZodString>;
+    code: z.ZodOptional<z.ZodEnum<{
+        conflict: "conflict";
+        forbidden: "forbidden";
+        internal: "internal";
+        not_found: "not_found";
+        permission_denied: "permission_denied";
+        precondition_failed: "precondition_failed";
+        rate_limited: "rate_limited";
+        unauthenticated: "unauthenticated";
+        unavailable: "unavailable";
+        validation_failed: "validation_failed";
+    }>>;
+    subject: z.ZodOptional<z.ZodString>;
+    expiresAt: z.core.$ZodBranded<z.ZodString, "Instant", "out">;
+    reason: z.ZodString;
+}, z.core.$strip>;
+export type FindingRuleInput = z.infer<typeof findingRuleInput>;
+export declare const findingRuleEntry: z.ZodObject<{
+    id: z.ZodString;
+    tenantId: z.core.$ZodBranded<z.ZodString, "TenantId", "out">;
+    kind: z.ZodNullable<z.ZodEnum<{
+        drift: "drift";
+        invariant: "invariant";
+        recurring: "recurring";
+    }>>;
+    operation: z.ZodNullable<z.ZodString>;
+    code: z.ZodNullable<z.ZodEnum<{
+        conflict: "conflict";
+        forbidden: "forbidden";
+        internal: "internal";
+        not_found: "not_found";
+        permission_denied: "permission_denied";
+        precondition_failed: "precondition_failed";
+        rate_limited: "rate_limited";
+        unauthenticated: "unauthenticated";
+        unavailable: "unavailable";
+        validation_failed: "validation_failed";
+    }>>;
+    subject: z.ZodNullable<z.ZodString>;
+    expiresAt: z.core.$ZodBranded<z.ZodString, "Instant", "out">;
+    reason: z.ZodString;
+    createdBy: z.ZodString;
+    createdAt: z.core.$ZodBranded<z.ZodString, "Instant", "out">;
+}, z.core.$strip>;
+export type FindingRuleEntry = z.infer<typeof findingRuleEntry>;
+/** Filter for `listFindings`. `tenantId` absent is the staff fleet read; a tenant's read is forced to it. */
+export interface FindingFilter {
+    tenantId?: z.infer<typeof tenantId>;
+    status?: FindingStatus;
+    kind?: FindingKind;
+    limit?: number;
+}
+//# sourceMappingURL=findings.d.ts.map

package/dist/findings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findings.d.ts","sourceRoot":"","sources":["../src/findings.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAoB,QAAQ,EAAE,MAAM,UAAU,CAAC;AAGtD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,WAAW;;;;EAA8C,CAAC;AACvE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEtD;;;;GAIG;AACH,eAAO,MAAM,aAAa;;;;;EAAsD,CAAC;AACjF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAE1D;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;EAAwC,CAAC;AACxE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE,eAAO,MAAM,eAAe;;;;EAA0C,CAAC;AACvE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,oGAAoG;AACpG,eAAO,MAAM,eAAe;;;;;;;;;;6BAK1B,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D;;;;GAIG;AACH,eAAO,MAAM,kBAAkB;;;;iBAK7B,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmCvB,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAExD,8GAA8G;AAC9G,eAAO,MAAM,qBAAqB,KAAK,CAAC;AAExC;;;;GAIG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;iBAWzB,CAAC;AACL,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;iBAW3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE,6GAA6G;AAC7G,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;IACpC,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB"}

package/dist/findings.js

@@ -0,0 +1,116 @@
+import { z } from 'zod';
+import { instant, scopeId, tenantId } from './ids.js';
+import { errorCode } from './errors.js';
+/**
+ * Findings (#1748): anomalies a tenant triages like email, in one inbox with one lifecycle.
+ *
+ * - `invariant`: a rule was broken — expected 0, observed N (a scheduled run that failed).
+ * - `drift`: unusual against an expectation — a freshness expectation gone stale.
+ * - `recurring`: one failure shape, seen again and again — the tenant's own projection of an
+ *   `_substrat_issues` fingerprint (#1233), counted over that tenant's occurrences only.
+ *
+ * A finding is TENANT-scoped by construction: its counters, versions and evidence come from
+ * that tenant's own rows, so the fleet aggregate it shares a fingerprint with is never visible
+ * through it. It carries no free text from the evidence (no message, no upstream reference):
+ * the evidence ref names where the rows are, and the reader reads them through its own
+ * tenant-forced view.
+ */
+export const findingKind = z.enum(['invariant', 'drift', 'recurring']);
+/**
+ * The lifecycle. `_substrat_issues` maps onto it 1:1 — new → `open`, regressed → `open` with
+ * `regressed`, resolved → `resolved`, ignored → `suppressed` — and `acked` is the one state an
+ * issue has no word for: "somebody is on it".
+ */
+export const findingStatus = z.enum(['open', 'acked', 'resolved', 'suppressed']);
+/**
+ * What a verdict may SET. `suppressed` is never set directly: it is what a suppress RULE does,
+ * because a suppression without a scope and an expiry is a finding nobody will ever see again.
+ */
+export const findingStatusInput = z.enum(['open', 'acked', 'resolved']);
+export const findingSeverity = z.enum(['info', 'warning', 'critical']);
+/** Where the occurrences behind a finding are read: the reader's own tenant-forced view of them. */
+export const findingEvidence = z.discriminatedUnion('source', [
+    /** `GET /ops-failures`, grouped by this fingerprint. */
+    z.object({ source: z.literal('ops-failures'), fingerprint: z.string().min(1) }),
+    /** `GET /sweep-runs?kind=…&unit=…`. */
+    z.object({ source: z.literal('sweep-runs'), kind: z.enum(['schedule', 'freshness']), unit: z.string().min(1) }),
+]);
+/**
+ * Why the finding is believed to have started, with the reason stated. Only `deploy` today: a
+ * finding that comes back under a version other than the one it was resolved under names the
+ * new version. Nothing is claimed when nothing changed — no cause is better than an invented one.
+ */
+export const findingLikelyCause = z.object({
+    kind: z.literal('deploy'),
+    /** The version-registry id the finding was seen under. */
+    version: z.string().min(1),
+    reason: z.string().min(1),
+});
+export const findingEntry = z.object({
+    id: z.string().min(1),
+    tenantId,
+    kind: findingKind,
+    /** The dedupe key within (tenant, kind): a fingerprint, or a sweep unit. */
+    subject: z.string().min(1),
+    status: findingStatus,
+    /** A fresh occurrence reopened a resolved finding. Cleared by the next `resolved` verdict. */
+    regressed: z.boolean(),
+    severity: findingSeverity,
+    title: z.string().min(1),
+    operation: z.string().nullable(),
+    /** The taxonomy codes seen on this finding, newest first, at most five. */
+    codes: z.array(errorCode),
+    vertical: z.string().nullable(),
+    scopeId: scopeId.nullable(),
+    /** This tenant's occurrences since the finding was first seen — never a fleet count. */
+    count: z.number().int().positive(),
+    firstSeen: instant,
+    lastSeen: instant,
+    lastVersion: z.string().nullable(),
+    /** `lastVersion` when the last `resolved` landed — the X of "resolved under X, seen again under Y". */
+    resolvedVersion: z.string().nullable(),
+    resolvedAt: instant.nullable(),
+    /**
+     * How the last resolve happened: a person's `verdict`, or `stale` — an open finding that went
+     * quiet for the whole retention window, resolved (and audited) by the retention pass rather
+     * than deleted out from under whoever was watching it.
+     */
+    resolution: z.enum(['verdict', 'stale']).nullable(),
+    acknowledgedAt: instant.nullable(),
+    /** The suppress rule holding it, while `suppressed`. */
+    ruleId: z.string().nullable(),
+    evidence: findingEvidence,
+    likelyCause: findingLikelyCause.nullable(),
+});
+/** The longest a suppression may last. A permanent "never show me this" is not a rule; it is a blind spot. */
+export const FINDING_RULE_MAX_DAYS = 90;
+/**
+ * A suppress rule (#1748): a scope plus an expiry. A matching occurrence is still COUNTED on its
+ * finding, but the finding stays `suppressed` instead of opening. Each set field narrows; at
+ * least one must be set, so a rule never silences a whole tenant.
+ */
+export const findingRuleInput = z
+    .object({
+    kind: findingKind.optional(),
+    operation: z.string().min(1).optional(),
+    code: errorCode.optional(),
+    subject: z.string().min(1).optional(),
+    expiresAt: instant,
+    reason: z.string().min(1).max(500),
+})
+    .refine((r) => r.kind !== undefined || r.operation !== undefined || r.code !== undefined || r.subject !== undefined, {
+    message: 'a suppress rule names at least one of kind, operation, code or subject',
+});
+export const findingRuleEntry = z.object({
+    id: z.string().min(1),
+    tenantId,
+    kind: findingKind.nullable(),
+    operation: z.string().nullable(),
+    code: errorCode.nullable(),
+    subject: z.string().nullable(),
+    expiresAt: instant,
+    reason: z.string(),
+    createdBy: z.string(),
+    createdAt: instant,
+});
+//# sourceMappingURL=findings.js.map

package/dist/findings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"findings.js","sourceRoot":"","sources":["../src/findings.ts"],"names":[],"mappings":"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"}