@tangle-network/agent-app 0.45.53 → 0.45.55

package/dist/record/fold.d.ts

@@ -0,0 +1,99 @@
+/**
+ * The fold: live entries in, one consumer-shaped object out.
+ *
+ * Pure and driver-free — the store loads rows and hands them here, and a test
+ * or an eval harness can call it with literals. Determinism is the contract:
+ * the result depends only on the CONTENT of the entries, never on the order
+ * they arrive in, because ordering is `seq` alone (with `id` as an unreachable
+ * tie-break — `(scope, seq)` is unique in storage). Nothing here reads a clock
+ * or a timestamp column, so two entries written in the same second still fold
+ * in a defined order.
+ *
+ * The consumer supplies the grouping rules: which paths carry forward across
+ * periods, how one entry applies to the accumulator, what a negative assertion
+ * retracts, and any derived values computed after the last entry.
+ */
+import { type RecordOutcome } from './model';
+/**
+ * How a path's entries resolve against the period being materialized.
+ *
+ * - `exact` — visible only at their own period. A value that was true for one
+ *   period is structurally invisible to every other one.
+ * - `carry-forward` — visible at any period at or after their own, and only
+ *   the newest such entry per key wins. Asserting a new value at a later
+ *   period changes that period onward and can never rewrite an earlier one.
+ */
+export type RecordPeriodScope = 'exact' | 'carry-forward';
+/** Resolves the period scope of one path. */
+export type RecordPeriodScopeResolver = (path: string) => RecordPeriodScope;
+/** The scope assumed for every path when a consumer supplies no resolver. */
+export declare const defaultRecordPeriodScope: RecordPeriodScopeResolver;
+/** The slice of a stored row the fold reads. */
+export interface FoldableRecordEntry {
+    id: string;
+    /** Per-scope monotonic write counter — the ONLY ordering key. */
+    seq: number;
+    dimension: string;
+    period: number;
+    path: string;
+    itemKey: string;
+    /** Canonical JSON produced by `canonicalRecordJson` on write. */
+    valueJson: string;
+    /** True when the entry asserts "there are none of these" at `path`. */
+    affirmedEmpty: boolean;
+}
+/** A resolved entry with its value already parsed, handed to the rules. */
+export interface DecodedRecordEntry extends FoldableRecordEntry {
+    /** `JSON.parse(valueJson)`; `null` on an `affirmedEmpty` entry. */
+    value: unknown;
+}
+/**
+ * The consumer's grouping rules. `T` is whatever shape the product folds into
+ * — a typed profile object, a keyed map, a list.
+ */
+export interface RecordFoldRules<T> {
+    /** Fresh accumulator for one fold. Must return a NEW object each call. */
+    init(): T;
+    /**
+     * Period scope for a path. Called for every entry, including paths that only
+     * ever appear as `affirmedEmpty` targets. Defaults to `'exact'` for every
+     * path when omitted, which is the narrower rule: an entry never leaks into a
+     * period it was not asserted for.
+     */
+    periodScope?: RecordPeriodScopeResolver;
+    /** Apply one entry to the accumulator. Fail loud: an entry the rules cannot
+     *  place must reject the whole fold, never be skipped — a silently dropped
+     *  entry shows a wrong number with a straight face. */
+    apply(draft: T, entry: DecodedRecordEntry): RecordOutcome<void>;
+    /** Apply a negative assertion. Runs at the entry's `seq`, so later entries
+     *  at the same path repopulate. Omit it to reject `affirmedEmpty` entries. */
+    retract?(draft: T, entry: DecodedRecordEntry): RecordOutcome<void>;
+    /** Compute derived values after the last entry. */
+    finalize?(draft: T): RecordOutcome<void>;
+}
+/** Options for one fold. */
+export interface FoldRecordEntriesOptions<T> {
+    rules: RecordFoldRules<T>;
+    /** The period being materialized. Defaults to
+     *  {@link RECORD_PERIOD_SENTINEL} for a record with no time dimension. */
+    period?: number;
+}
+/** What a fold produced. */
+export interface RecordFoldResult<T> {
+    value: T;
+    /** Entries that survived period resolution and were applied. */
+    entryCount: number;
+}
+/**
+ * True when an entry at `entryPeriod` is a candidate at `requestedPeriod`
+ * under `scope`. Carry-forward candidacy is necessary, not sufficient — only
+ * the newest candidate per key survives {@link foldRecordEntries}.
+ */
+export declare function recordEntryVisibleInPeriod(scope: RecordPeriodScope, entryPeriod: number, requestedPeriod: number): boolean;
+/**
+ * Resolve entries against the requested period, then fold them in `seq` order.
+ *
+ * Callers may pass entries in any order and any mix of periods; the result is
+ * a function of their content alone.
+ */
+export declare function foldRecordEntries<T>(entries: readonly FoldableRecordEntry[], options: FoldRecordEntriesOptions<T>): RecordOutcome<RecordFoldResult<T>>;

package/dist/record/index.d.ts

@@ -1,16 +1,16 @@
-export { D as DecodedRecordEntry, F as FoldRecordEntriesOptions, a as FoldableRecordEntry, R as RECORD_KEY_SENTINEL, b as RECORD_PERIOD_SENTINEL, c as RECORD_REVIEW_STATES, d as RecordEntryKey, e as RecordErrorCode, f as RecordFoldResult, g as RecordFoldRules, h as RecordKeyCanonicalizer, i as RecordMaterialDifference, j as RecordOutcome, k as RecordParseResult, l as RecordPeriodScope, m as RecordPeriodScopeResolver, n as RecordReviewState, o as RecordSchemaMap, p as RecordSourceLocator, q as RecordValueValidator, r as RecordWritePolicy, s as canonicalRecordJson, t as defaultRecordMaterialDifference, u as defaultRecordPeriodScope, v as detectRecordConflict, w as foldRecordEntries, x as recordEntryVisibleInPeriod, y as recordFail, z as recordKeyString, A as recordOk, B as resolveWriteReviewState, C as validateRecordValue } from '../fold-DACU7gtf.js';
-
 /**
- * ULID — a 26-character Crockford-base32 id: a 48-bit millisecond timestamp
- * followed by 80 bits from `crypto.getRandomValues`.
+ * `@tangle-network/agent-app/record` — the source-cited, reviewable,
+ * supersedable entry store, minus the database.
  *
- * The record store mints ids in application code rather than taking a column
- * default, because an atomic supersede stamps the REPLACEMENT's id onto the
- * outgoing head in the same write — the id has to exist before the insert.
- * Lexicographic order approximates creation order, which keeps a raw table
- * scan readable; strict fold ordering comes from `seq`, never from the id.
+ * This leaf is import-free: types, the key sentinels, canonical value
+ * encoding, consumer-supplied validation, the conflict rule, and the pure
+ * fold. A browser surface rendering a review queue and a worker writing rows
+ * share exactly this vocabulary.
+ *
+ * The drizzle table factory and the store live behind
+ * `@tangle-network/agent-app/record/drizzle`, because they import `drizzle-orm`
+ * at module top and it is an optional peer.
  */
-/** Mint a ULID. `now` is exposed so a caller can pin time in a test. */
-declare function recordUlid(now?: number): string;
-
-export { recordUlid };
+export * from './model';
+export * from './fold';
+export * from './ulid';

package/dist/{fold-DACU7gtf.d.ts → record/model.d.ts}

@@ -15,7 +15,7 @@
  * by the consumer. This module knows none of them.
  */
 /** Error classes a caller maps to a status code or a retry decision. */
-type RecordErrorCode = 
+export type RecordErrorCode = 
 /** The path is not a key of the consumer's schema map. */
 'unknown-path'
 /** The value failed the consumer's schema for its path. */
@@ -41,7 +41,7 @@ type RecordErrorCode =
  * before reading `value`; nothing here throws past its own boundary except a
  * programming error in the consumer's own callbacks.
  */
-type RecordOutcome<T> = {
+export type RecordOutcome<T> = {
     succeeded: true;
     value: T;
 } | {
@@ -50,9 +50,9 @@ type RecordOutcome<T> = {
     code: RecordErrorCode;
 };
 /** Build a success outcome. */
-declare function recordOk<T>(value: T): RecordOutcome<T>;
+export declare function recordOk<T>(value: T): RecordOutcome<T>;
 /** Build a failure outcome carrying its error class. */
-declare function recordFail(code: RecordErrorCode, error: string): RecordOutcome<never>;
+export declare function recordFail(code: RecordErrorCode, error: string): RecordOutcome<never>;
 /**
  * Sentinel for an unused key column.
  *
@@ -61,29 +61,29 @@ declare function recordFail(code: RecordErrorCode, error: string): RecordOutcome
  * is therefore NOT NULL with a sentinel, and this is the sentinel for the two
  * text ones (`dimension`, `itemKey`).
  */
-declare const RECORD_KEY_SENTINEL = "";
+export declare const RECORD_KEY_SENTINEL = "";
 /**
  * Sentinel period for a record with no time dimension. Same reason as
  * {@link RECORD_KEY_SENTINEL}: the column is NOT NULL so the unique index over
  * the live head actually dedupes. A consumer with no period concept writes
  * every entry at `0` and materializes at `0`.
  */
-declare const RECORD_PERIOD_SENTINEL = 0;
+export declare const RECORD_PERIOD_SENTINEL = 0;
 /** Lifecycle of one entry. `accepted` requires a structured act — a source
  *  kind the policy trusts, or an explicit review. */
-type RecordReviewState = 'proposed' | 'accepted' | 'rejected';
+export type RecordReviewState = 'proposed' | 'accepted' | 'rejected';
 /** Every review state, for iteration and validation. */
-declare const RECORD_REVIEW_STATES: readonly RecordReviewState[];
+export declare const RECORD_REVIEW_STATES: readonly RecordReviewState[];
 /** Position of the assertion inside its source. All fields optional — a chat
  *  message has no page, a scraped row has no character span. */
-interface RecordSourceLocator {
+export interface RecordSourceLocator {
     page?: number;
     charStart?: number;
     charEnd?: number;
 }
 /** The columns that identify which assertion an entry supersedes. Two entries
  *  with the same key compete for the same live head. */
-interface RecordEntryKey {
+export interface RecordEntryKey {
     /** Consumer-defined partition inside a scope — whatever second axis the
      *  product folds along. {@link RECORD_KEY_SENTINEL} when unused. */
     dimension: string;
@@ -97,17 +97,17 @@ interface RecordEntryKey {
     period: number;
 }
 /** Join an entry key into one comparable string, for grouping in memory. */
-declare function recordKeyString(key: RecordEntryKey): string;
+export declare function recordKeyString(key: RecordEntryKey): string;
 /**
  * Deterministic JSON with object keys sorted at every depth. Two values that
  * differ only in key order encode identically, so the conflict rule never
  * fires on serialization noise and the fold's stored value is stable.
  */
-declare function canonicalRecordJson(value: unknown): string;
+export declare function canonicalRecordJson(value: unknown): string;
 /** The result shape a `safeParse`-style validator returns. `zod`'s schemas
  *  satisfy this structurally, so a consumer passes its zod schema directly and
  *  this module takes no schema-library dependency. */
-type RecordParseResult = {
+export type RecordParseResult = {
     success: true;
     data: unknown;
 } | {
@@ -116,7 +116,7 @@ type RecordParseResult = {
 };
 /** Something that can validate one value for one path: a `safeParse` object
  *  (zod and friends) or a plain function returning a typed outcome. */
-type RecordValueValidator = {
+export type RecordValueValidator = {
     safeParse(value: unknown): RecordParseResult;
 } | ((value: unknown) => RecordOutcome<unknown>);
 /**
@@ -124,15 +124,15 @@ type RecordValueValidator = {
  * map is rejected with `unknown-path`, so nothing the consumer's fold cannot
  * type-check ever reaches storage.
  */
-type RecordSchemaMap = Readonly<Record<string, RecordValueValidator>>;
+export type RecordSchemaMap = Readonly<Record<string, RecordValueValidator>>;
 /** Run one validator, normalizing both forms to a typed outcome and flattening
  *  a `safeParse` error into a readable message. */
-declare function validateRecordValue(validator: RecordValueValidator, value: unknown): RecordOutcome<unknown>;
+export declare function validateRecordValue(validator: RecordValueValidator, value: unknown): RecordOutcome<unknown>;
 /**
  * How a live accepted head at the same key is compared against an incoming
  * write. Returning `true` means the two assertions genuinely disagree.
  */
-type RecordMaterialDifference = (head: {
+export type RecordMaterialDifference = (head: {
     sourceKind: string;
     valueJson: string;
     affirmedEmpty: boolean;
@@ -148,16 +148,16 @@ type RecordMaterialDifference = (head: {
  * kind is a refresh, not a disagreement; an identical value from another
  * source kind is corroboration.
  */
-declare const defaultRecordMaterialDifference: RecordMaterialDifference;
+export declare const defaultRecordMaterialDifference: RecordMaterialDifference;
 /** Canonicalize a key column before it enters the fold key (upper-casing a
  *  region code, trimming an identifier). Rejecting is fail-loud, never a
  *  silent rewrite to a sentinel. */
-type RecordKeyCanonicalizer = (path: string, raw: string) => RecordOutcome<string>;
+export type RecordKeyCanonicalizer = (path: string, raw: string) => RecordOutcome<string>;
 /**
  * Everything domain-specific about writing an entry, supplied by the consumer.
  * The store holds no defaults for any of it except the conflict rule.
  */
-interface RecordWritePolicy {
+export interface RecordWritePolicy {
     /** Path → validator; the key set is the write allowlist. */
     schemas: RecordSchemaMap;
     /**
@@ -204,10 +204,10 @@ interface RecordWritePolicy {
 }
 /** Resolve the review state a write from `sourceKind` lands in, failing loud
  *  on a kind the policy never declared. */
-declare function resolveWriteReviewState(policy: RecordWritePolicy, sourceKind: string): RecordOutcome<RecordReviewState>;
+export declare function resolveWriteReviewState(policy: RecordWritePolicy, sourceKind: string): RecordOutcome<RecordReviewState>;
 /** True when the incoming write disagrees with the live head under the
  *  policy's rule (or the default). */
-declare function detectRecordConflict(policy: RecordWritePolicy, head: {
+export declare function detectRecordConflict(policy: RecordWritePolicy, head: {
     sourceKind: string;
     valueJson: string;
     affirmedEmpty: boolean;
@@ -216,105 +216,3 @@ declare function detectRecordConflict(policy: RecordWritePolicy, head: {
     valueJson: string;
     affirmedEmpty: boolean;
 }): boolean;
-
-/**
- * The fold: live entries in, one consumer-shaped object out.
- *
- * Pure and driver-free — the store loads rows and hands them here, and a test
- * or an eval harness can call it with literals. Determinism is the contract:
- * the result depends only on the CONTENT of the entries, never on the order
- * they arrive in, because ordering is `seq` alone (with `id` as an unreachable
- * tie-break — `(scope, seq)` is unique in storage). Nothing here reads a clock
- * or a timestamp column, so two entries written in the same second still fold
- * in a defined order.
- *
- * The consumer supplies the grouping rules: which paths carry forward across
- * periods, how one entry applies to the accumulator, what a negative assertion
- * retracts, and any derived values computed after the last entry.
- */
-
-/**
- * How a path's entries resolve against the period being materialized.
- *
- * - `exact` — visible only at their own period. A value that was true for one
- *   period is structurally invisible to every other one.
- * - `carry-forward` — visible at any period at or after their own, and only
- *   the newest such entry per key wins. Asserting a new value at a later
- *   period changes that period onward and can never rewrite an earlier one.
- */
-type RecordPeriodScope = 'exact' | 'carry-forward';
-/** Resolves the period scope of one path. */
-type RecordPeriodScopeResolver = (path: string) => RecordPeriodScope;
-/** The scope assumed for every path when a consumer supplies no resolver. */
-declare const defaultRecordPeriodScope: RecordPeriodScopeResolver;
-/** The slice of a stored row the fold reads. */
-interface FoldableRecordEntry {
-    id: string;
-    /** Per-scope monotonic write counter — the ONLY ordering key. */
-    seq: number;
-    dimension: string;
-    period: number;
-    path: string;
-    itemKey: string;
-    /** Canonical JSON produced by `canonicalRecordJson` on write. */
-    valueJson: string;
-    /** True when the entry asserts "there are none of these" at `path`. */
-    affirmedEmpty: boolean;
-}
-/** A resolved entry with its value already parsed, handed to the rules. */
-interface DecodedRecordEntry extends FoldableRecordEntry {
-    /** `JSON.parse(valueJson)`; `null` on an `affirmedEmpty` entry. */
-    value: unknown;
-}
-/**
- * The consumer's grouping rules. `T` is whatever shape the product folds into
- * — a typed profile object, a keyed map, a list.
- */
-interface RecordFoldRules<T> {
-    /** Fresh accumulator for one fold. Must return a NEW object each call. */
-    init(): T;
-    /**
-     * Period scope for a path. Called for every entry, including paths that only
-     * ever appear as `affirmedEmpty` targets. Defaults to `'exact'` for every
-     * path when omitted, which is the narrower rule: an entry never leaks into a
-     * period it was not asserted for.
-     */
-    periodScope?: RecordPeriodScopeResolver;
-    /** Apply one entry to the accumulator. Fail loud: an entry the rules cannot
-     *  place must reject the whole fold, never be skipped — a silently dropped
-     *  entry shows a wrong number with a straight face. */
-    apply(draft: T, entry: DecodedRecordEntry): RecordOutcome<void>;
-    /** Apply a negative assertion. Runs at the entry's `seq`, so later entries
-     *  at the same path repopulate. Omit it to reject `affirmedEmpty` entries. */
-    retract?(draft: T, entry: DecodedRecordEntry): RecordOutcome<void>;
-    /** Compute derived values after the last entry. */
-    finalize?(draft: T): RecordOutcome<void>;
-}
-/** Options for one fold. */
-interface FoldRecordEntriesOptions<T> {
-    rules: RecordFoldRules<T>;
-    /** The period being materialized. Defaults to
-     *  {@link RECORD_PERIOD_SENTINEL} for a record with no time dimension. */
-    period?: number;
-}
-/** What a fold produced. */
-interface RecordFoldResult<T> {
-    value: T;
-    /** Entries that survived period resolution and were applied. */
-    entryCount: number;
-}
-/**
- * True when an entry at `entryPeriod` is a candidate at `requestedPeriod`
- * under `scope`. Carry-forward candidacy is necessary, not sufficient — only
- * the newest candidate per key survives {@link foldRecordEntries}.
- */
-declare function recordEntryVisibleInPeriod(scope: RecordPeriodScope, entryPeriod: number, requestedPeriod: number): boolean;
-/**
- * Resolve entries against the requested period, then fold them in `seq` order.
- *
- * Callers may pass entries in any order and any mix of periods; the result is
- * a function of their content alone.
- */
-declare function foldRecordEntries<T>(entries: readonly FoldableRecordEntry[], options: FoldRecordEntriesOptions<T>): RecordOutcome<RecordFoldResult<T>>;
-
-export { recordOk as A, resolveWriteReviewState as B, validateRecordValue as C, type DecodedRecordEntry as D, type FoldRecordEntriesOptions as F, RECORD_KEY_SENTINEL as R, type FoldableRecordEntry as a, RECORD_PERIOD_SENTINEL as b, RECORD_REVIEW_STATES as c, type RecordEntryKey as d, type RecordErrorCode as e, type RecordFoldResult as f, type RecordFoldRules as g, type RecordKeyCanonicalizer as h, type RecordMaterialDifference as i, type RecordOutcome as j, type RecordParseResult as k, type RecordPeriodScope as l, type RecordPeriodScopeResolver as m, type RecordReviewState as n, type RecordSchemaMap as o, type RecordSourceLocator as p, type RecordValueValidator as q, type RecordWritePolicy as r, canonicalRecordJson as s, defaultRecordMaterialDifference as t, defaultRecordPeriodScope as u, detectRecordConflict as v, foldRecordEntries as w, recordEntryVisibleInPeriod as x, recordFail as y, recordKeyString as z };

package/dist/record/ulid.d.ts

@@ -0,0 +1,12 @@
+/**
+ * ULID — a 26-character Crockford-base32 id: a 48-bit millisecond timestamp
+ * followed by 80 bits from `crypto.getRandomValues`.
+ *
+ * The record store mints ids in application code rather than taking a column
+ * default, because an atomic supersede stamps the REPLACEMENT's id onto the
+ * outgoing head in the same write — the id has to exist before the insert.
+ * Lexicographic order approximates creation order, which keeps a raw table
+ * scan readable; strict fold ordering comes from `seq`, never from the id.
+ */
+/** Mint a ULID. `now` is exposed so a caller can pin time in a test. */
+export declare function recordUlid(now?: number): string;

package/dist/redact/index.d.ts

@@ -20,7 +20,7 @@
  */
 /** A named PII pattern. `pattern` is matched case-insensitively at the string
  *  level; keep it non-global (global instances are derived where needed). */
-interface RedactionPattern {
+export interface RedactionPattern {
     kind: string;
     pattern: RegExp;
     /** Optional predicate over each match — the pattern fires only when it returns
@@ -32,9 +32,9 @@ interface RedactionPattern {
 /** The default deterministic patterns. Extend via the `extraPatterns` /
  *  `patterns` options rather than forking this module (the seam that lets a
  *  product add e.g. a credit-card matcher without a local copy). */
-declare const DEFAULT_REDACTION_PATTERNS: readonly RedactionPattern[];
+export declare const DEFAULT_REDACTION_PATTERNS: readonly RedactionPattern[];
 /** Define options to customize sensitive data redaction patterns and key names for ingestion */
-interface RedactForIngestionOptions {
+export interface RedactForIngestionOptions {
     /** Extra patterns appended to {@link DEFAULT_REDACTION_PATTERNS} for the
      *  string-level scrub (e.g. credit-card). Additive — defaults still apply. */
     extraPatterns?: readonly RedactionPattern[];
@@ -58,16 +58,16 @@ interface RedactForIngestionOptions {
  * non-overlap, and `validate` predicates behave identically to the reversible
  * path. Each span becomes `[REDACTED:<kind>]`.
  */
-declare function maskSpans(text: string, patterns?: readonly RedactionPattern[]): string;
+export declare function maskSpans(text: string, patterns?: readonly RedactionPattern[]): string;
 /**
  * One-way PII scrub for telemetry/ingestion. Backward-compatible: called with no
  * options it behaves exactly as before (SSN/EIN strings + sensitive object keys
  * → sentinels). `extraPatterns` lets a product add matchers (e.g. credit-card)
  * without forking this module.
  */
-declare function redactForIngestion(value: unknown, options?: RedactForIngestionOptions): unknown;
+export declare function redactForIngestion(value: unknown, options?: RedactForIngestionOptions): unknown;
 /** A detected PII span in a source string. */
-interface RedactionSpan {
+export interface RedactionSpan {
     /** Stable within a document (index-derived) — used for reveal + audit. */
     id: string;
     kind: string;
@@ -80,10 +80,10 @@ interface RedactionSpan {
  * position, and drops overlaps (first match wins). Deterministic — no ids that
  * vary per call.
  */
-declare function detectSpans(text: string, patterns?: readonly RedactionPattern[]): RedactionSpan[];
+export declare function detectSpans(text: string, patterns?: readonly RedactionPattern[]): RedactionSpan[];
 /** A redacted document segment: literal text, or a masked span with the
  *  original kept ENCRYPTED for an authorized reveal. */
-type RedactedDocSegment = {
+export type RedactedDocSegment = {
     type: 'text';
     text: string;
 } | {
@@ -93,11 +93,11 @@ type RedactedDocSegment = {
     cipher: string;
 };
 /** Define a document composed of multiple redacted content segments */
-interface RedactedDocument {
+export interface RedactedDocument {
     segments: RedactedDocSegment[];
 }
 /** Define options to encrypt text and specify patterns for redacting sensitive document content */
-interface BuildRedactedDocumentOptions {
+export interface BuildRedactedDocumentOptions {
     /** Encrypt one original span value. Wire it to `agent-app/crypto`
      *  (`encryptWithKey` / `createFieldCrypto`). The cipher is what's stored. */
     encrypt: (plaintext: string) => string | Promise<string>;
@@ -110,9 +110,9 @@ interface BuildRedactedDocumentOptions {
  * ciphertext — so it is safe to ship to a client; reveal happens server-side via
  * {@link revealSpan}.
  */
-declare function buildRedactedDocument(text: string, options: BuildRedactedDocumentOptions): Promise<RedactedDocument>;
+export declare function buildRedactedDocument(text: string, options: BuildRedactedDocumentOptions): Promise<RedactedDocument>;
 /** Define options to decrypt, authorize, and audit the reveal of a span segment */
-interface RevealSpanOptions {
+export interface RevealSpanOptions {
     /** Decrypt a span cipher. Wire to `agent-app/crypto` (`decryptWithKey`). */
     decrypt: (cipher: string) => string | Promise<string>;
     /** Authorization gate — return false to deny the reveal (fail-closed). */
@@ -127,7 +127,7 @@ interface RevealSpanOptions {
     }) => void | Promise<void>;
 }
 /** Describe the outcome of a reveal operation including success status, value, and failure reason */
-interface RevealResult {
+export interface RevealResult {
     ok: boolean;
     value?: string;
     /** `not_found` | `forbidden` when `ok` is false. */
@@ -139,6 +139,4 @@ interface RevealResult {
  * granted reveal decrypts, fires `onReveal` for the audit trail, and returns the
  * value.
  */
-declare function revealSpan(doc: RedactedDocument, spanId: string, options: RevealSpanOptions): Promise<RevealResult>;
-
-export { type BuildRedactedDocumentOptions, DEFAULT_REDACTION_PATTERNS, type RedactForIngestionOptions, type RedactedDocSegment, type RedactedDocument, type RedactionPattern, type RedactionSpan, type RevealResult, type RevealSpanOptions, buildRedactedDocument, detectSpans, maskSpans, redactForIngestion, revealSpan };
+export declare function revealSpan(doc: RedactedDocument, spanId: string, options: RevealSpanOptions): Promise<RevealResult>;

package/dist/run/index.d.ts

@@ -1,6 +1,3 @@
-import { Harness } from '../harness/index.js';
-import '@tangle-network/agent-interface';
-
 /**
  * Execution-mode dispatch — the shell entry that infers *how* to run an agent
  * from its profile's harness, so a product hands over one profile and the
@@ -18,16 +15,16 @@ import '@tangle-network/agent-interface';
  * `router`/`sandbox` thunk and can lazy-import the sandbox driver inside its own
  * thunk, so a router-only app never resolves `@tangle-network/sandbox`.
  */
-
+import { type Harness } from '../harness/index';
 /** Define execution mode as either router or sandbox */
-type ExecutionMode = 'router' | 'sandbox';
+export type ExecutionMode = 'router' | 'sandbox';
 /** The router pseudo-harness — the absence of a sandbox backend. Not a member
  *  of `KNOWN_HARNESSES`; callers may pass it explicitly instead of null. */
-declare const ROUTER_HARNESS: "router";
+export declare const ROUTER_HARNESS: "router";
 /** Provide a type alias for the ROUTER_HARNESS constant to enable consistent router harness usage */
-type RouterHarness = typeof ROUTER_HARNESS;
+export type RouterHarness = typeof ROUTER_HARNESS;
 /** Resolve a ProfileHarness as a Harness, RouterHarness, null, or undefined value */
-type ProfileHarness = Harness | RouterHarness | null | undefined;
+export type ProfileHarness = Harness | RouterHarness | null | undefined;
 /**
  * Infer the execution mode from a profile's harness. Absent / null / 'router'
  * => 'router'; a known sandbox harness => 'sandbox'. An unrecognized non-null
@@ -35,25 +32,25 @@ type ProfileHarness = Harness | RouterHarness | null | undefined;
  * unknown id is a sandbox the runtime resolves, not a router) — callers that
  * want strictness can validate against `KNOWN_HARNESSES` first.
  */
-declare function resolveExecutionMode(harness: ProfileHarness): ExecutionMode;
+export declare function resolveExecutionMode(harness: ProfileHarness): ExecutionMode;
 /** True when `harness` names a sandbox backend the SDK knows about. */
-declare function isKnownSandboxHarness(harness: ProfileHarness): harness is Harness;
+export declare function isKnownSandboxHarness(harness: ProfileHarness): harness is Harness;
 /**
  * The superset the dispatch reads: the SDK `AgentProfile` plus the harness
  * discriminator. Intentionally pins only `harness` — the rest of the profile is
  * carried opaquely so this module stays free of the SDK type (router-only apps
  * import it without `@tangle-network/sandbox`).
  */
-interface ShellProfile {
+export interface ShellProfile {
     harness?: ProfileHarness;
 }
 /** Execution mode for a profile — `harness` omitted/null => router. */
-declare function executionModeForProfile(profile: ShellProfile): ExecutionMode;
+export declare function executionModeForProfile(profile: ShellProfile): ExecutionMode;
 /** The two branch runners. Each returns (or resolves to) an async iterable of
  *  the product's own event type — the shapes differ, so the product owns them.
  *  A `sandbox` thunk can `await import('@tangle-network/agent-app/sandbox')`
  *  internally so the SDK is pulled only on the sandbox path. */
-interface RunAgentBranches<T> {
+export interface RunAgentBranches<T> {
     router: () => AsyncIterable<T> | Promise<AsyncIterable<T>>;
     sandbox: () => AsyncIterable<T> | Promise<AsyncIterable<T>>;
 }
@@ -63,6 +60,4 @@ interface RunAgentBranches<T> {
  * unselected branch's thunk is never invoked — so its dependencies (e.g. the
  * sandbox SDK) are never loaded on the other path.
  */
-declare function runAgent<T>(harness: ProfileHarness, branches: RunAgentBranches<T>): AsyncGenerator<T>;
-
-export { type ExecutionMode, type ProfileHarness, ROUTER_HARNESS, type RouterHarness, type RunAgentBranches, type ShellProfile, executionModeForProfile, isKnownSandboxHarness, resolveExecutionMode, runAgent };
+export declare function runAgent<T>(harness: ProfileHarness, branches: RunAgentBranches<T>): AsyncGenerator<T>;

package/dist/runtime/agent.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The resolved per-turn profile surfaces a delivered / certified `AgentProfile`
+ * can change.
+ *
+ * This file used to also carry `createAgentRuntime` — a factory that hand-wired
+ * `resolveTangleModelConfig` + `buildAppToolOpenAITools` + `createOpenAICompatStreamTurn`
+ * + `createAppToolRuntimeExecutor` + `runAppToolLoop` into one object. It shipped
+ * for the whole life of the package and never acquired a consumer (0 references
+ * across all nine repos on the fleet's default branches), while every product
+ * that drives an in-process model turn composes those five directly or uses
+ * `handleChatTurn`. It was removed in 0.44.0; compose the pieces, or see
+ * `examples/browser-copilot.md` for the sandbox-free assembly.
+ */
+/** The agent's resolved profile surfaces for one turn — the things a delivered
+ *  / certified `AgentProfile` can change. Profile-WIDE on purpose: certified
+ *  delivery folds prompt-surface + skills into `systemPrompt` AND can add
+ *  certified `tool` artifacts to `extraTools`. MCP servers / memory / RAG that
+ *  materialize as files or servers deliver through the sandbox-provisioning
+ *  seam, not here. */
+export interface ResolvedAgentProfile {
+    systemPrompt: string;
+    extraTools: unknown[];
+}

package/dist/runtime/certified-delivery.d.ts

@@ -0,0 +1,57 @@
+/**
+ * `createCertifiedDelivery` — the delivery truck for Tangle Intelligence.
+ *
+ * Pulls a tenant's CERTIFIED `AgentProfile` from the deployed plane
+ * (`GET /v1/profiles/:target/composed`) and applies it to the agent's resolved
+ * surfaces each turn, so an approved improvement reaches the running agent with
+ * NO redeploy. This is the `composeProfile` transform `createAgentRuntime`
+ * accepts — opt-in per product, fail-closed, cached + refreshed.
+ *
+ * Profile-WIDE by design (not prompt-only): the composed profile carries every
+ * promoted artifact type keyed by kind. What's folded where:
+ *   - `prompt-surface` + `skill` → the system prompt (via `composeCertifiedPrompt`).
+ *   - `tool` artifacts that carry an OpenAI tool definition → `extraTools`
+ *     (advertised to the model; the matching executor is supplied by the product
+ *     via `executeOtherTool`). Until a `tool` artifact carries a runnable def,
+ *     it is surfaced (see `current()`) but not advertised — advertising a tool
+ *     with no executor would make the model call into a dead end.
+ *   - `mcp` / `memory` / `rag` artifacts materialize as servers/files and deliver
+ *     through the SANDBOX-provisioning seam, not this in-process one. The full
+ *     certified profile is exposed via `current()` so that seam can consume it.
+ *
+ * Substrate boundary: THIS module imports `@tangle-network/agent-runtime`; the
+ * `createAgentRuntime` core does not (it only consumes the generic transform).
+ */
+import { type CertifiedProfile } from '@tangle-network/agent-runtime/intelligence';
+import type { ResolvedAgentProfile } from './agent';
+/** Define configuration options for delivering certified artifacts to a specified tenant target */
+export interface CertifiedDeliveryConfig {
+    /** The tenant target whose certified artifacts to deliver (the agent id). */
+    target: string;
+    /** Bearer for the plane. Reads `TANGLE_API_KEY` when omitted. */
+    apiKey?: string;
+    /** Plane base URL. Reads `TANGLE_INTELLIGENCE_URL` then the public plane. */
+    baseUrl?: string;
+    /** Min interval between certified-profile pulls. Default 5m. */
+    refreshMs?: number;
+    /** fetch impl (tests / non-global-fetch runtimes). */
+    fetchImpl?: typeof fetch;
+}
+/** Resolve and manage certified profiles with refresh and composition capabilities */
+export interface CertifiedDelivery {
+    /** The `composeProfile` transform to pass to `createAgentRuntime`. Applies the
+     *  cached certified profile to the base surfaces; refreshes on the cadence. */
+    composeProfile(base: ResolvedAgentProfile): Promise<ResolvedAgentProfile>;
+    /** Force a pull now (ignores the refresh window). Best-effort. */
+    refresh(): Promise<void>;
+    /** The certified profile currently in effect (null = none promoted / pull
+     *  failed). Lets the sandbox-provisioning seam deliver the file/server
+     *  artifact types this in-process seam doesn't. */
+    current(): CertifiedProfile | null;
+}
+/**
+ * Build a certified-delivery transform for one agent target. Fail-closed: a pull
+ * error or 404 keeps the last-known certified profile (or null), and the agent
+ * runs on its base surfaces — it never breaks because Intelligence is down.
+ */
+export declare function createCertifiedDelivery(config: CertifiedDeliveryConfig): CertifiedDelivery;