@tangle-network/agent-app 0.45.53 → 0.45.55

package/dist/config/index.d.ts

@@ -1,8 +1,3 @@
-import { KnowledgeRequirementSpec } from '../knowledge/index.js';
-export { SatisfiedByRule } from '../knowledge/index.js';
-import { T as TangleModelConfig } from '../model-CdCDfBA9.js';
-import '@tangle-network/agent-eval';
-
 /**
  * `@tangle-network/agent-app/config` — the typed `AgentAppConfig` contract.
  *
@@ -31,12 +26,14 @@ import '@tangle-network/agent-eval';
  * config a product authors is the exact shape those modules already consume.
  * Steps that build the composer/loader read this file as the schema floor.
  */
-
+import type { KnowledgeRequirementSpec, SatisfiedByRule } from '../knowledge/index';
+import type { TangleModelConfig } from '../runtime/index';
+export type { KnowledgeRequirementSpec, SatisfiedByRule, TangleModelConfig };
 /**
  * Who the agent is, as data. Composed into the chat pipeline's system prompt;
  * never baked into agent-app (a domain value, per the layering contract).
  */
-interface AgentIdentityConfig {
+export interface AgentIdentityConfig {
     /** Product/agent name, e.g. `"Acme Support Copilot"`. Shown to the user and
      *  available to the system-prompt builder. */
     name: string;
@@ -58,7 +55,7 @@ interface AgentIdentityConfig {
  * a certified human approver. `regulatedTypes` MUST be a subset of
  * `proposalTypes` (validated by the loader step; not enforced at the type level).
  */
-interface AgentTaxonomyConfig {
+export interface AgentTaxonomyConfig {
     /** Every proposal type this product can emit, e.g.
      *  `['recommend', 'contact', 'escalate']`. The closed allow-list
      *  the tool layer validates a `submit_proposal` call against. */
@@ -69,7 +66,7 @@ interface AgentTaxonomyConfig {
     regulatedTypes: string[];
 }
 /** A knowledge source the acquisition loop / researcher may draw on. */
-interface KnowledgeSourceSpec {
+export interface KnowledgeSourceSpec {
     /** Where the source lives — a URL, a `vault://` path, an integration ref, etc.
      *  Opaque to agent-app; the consumer's loader resolves it. */
     uri: string;
@@ -82,7 +79,7 @@ interface KnowledgeSourceSpec {
  * the gate it must clear before the loop is considered satisfied. All optional;
  * a product with only static requirement specs omits it.
  */
-interface KnowledgeLoopConfig {
+export interface KnowledgeLoopConfig {
     /** The acquisition goal in natural language, e.g.
      *  `"ground every quoted premium against a real policy record"`. */
     goal?: string;
@@ -100,7 +97,7 @@ interface KnowledgeLoopConfig {
  * loop (reused verbatim — the same `KnowledgeRequirementSpec` the gate scores);
  * `loop` configures the acquisition pass.
  */
-interface AgentKnowledgeConfig {
+export interface AgentKnowledgeConfig {
     /** Sources the acquisition loop / researcher may draw on. */
     sources: KnowledgeSourceSpec[];
     /** The declarative requirement specs that gate the loop. Reuses
@@ -117,12 +114,12 @@ interface AgentKnowledgeConfig {
  * each to a connector. Strings, not connector objects — agent-app bakes no
  * catalog value.
  */
-interface AgentIntegrationsConfig {
+export interface AgentIntegrationsConfig {
     /** Catalog kinds this product enables. */
     enabled: string[];
 }
 /** UI capability flags, as data. */
-interface AgentUiConfig {
+export interface AgentUiConfig {
     /** Whether the agent may emit generated UI (the `render_ui` / OpenUI side
      *  channel). When false/omitted, the tool layer can omit/refuse the tool.
      *  Default behavior decided by the consumer; omit to leave unset. */
@@ -137,7 +134,7 @@ interface AgentUiConfig {
  * seam — no field is behavior. Author it through {@link defineAgentApp} for
  * autocomplete and a single import.
  */
-interface AgentAppConfig {
+export interface AgentAppConfig {
     /** Who the agent is — name, persona, system-prompt fragments, disclaimers. */
     identity: AgentIdentityConfig;
     /** Proposal types + which are regulated/approval-gated. */
@@ -168,7 +165,7 @@ interface AgentAppConfig {
  * })
  * ```
  */
-declare function defineAgentApp<const T extends AgentAppConfig>(config: T): T;
+export declare function defineAgentApp<const T extends AgentAppConfig>(config: T): T;
 /**
  * Machine-readable JSON Schema (draft 2020-12) for {@link AgentAppConfig}.
  *
@@ -179,7 +176,7 @@ declare function defineAgentApp<const T extends AgentAppConfig>(config: T): T;
  * `additionalProperties: true` here — its authoritative definition lives in
  * `../knowledge`; this floor pins only the fields the config contract owns.
  */
-declare const agentAppConfigJsonSchema: {
+export declare const agentAppConfigJsonSchema: {
     readonly $schema: "https://json-schema.org/draft/2020-12/schema";
     readonly $id: "https://tangle.tools/schemas/agent-app-config.json";
     readonly title: "AgentAppConfig";
@@ -341,5 +338,3 @@ declare const agentAppConfigJsonSchema: {
         };
     };
 };
-
-export { type AgentAppConfig, type AgentIdentityConfig, type AgentIntegrationsConfig, type AgentKnowledgeConfig, type AgentTaxonomyConfig, type AgentUiConfig, type KnowledgeLoopConfig, KnowledgeRequirementSpec, type KnowledgeSourceSpec, TangleModelConfig, agentAppConfigJsonSchema, defineAgentApp };

package/dist/crypto/index.d.ts

@@ -10,16 +10,16 @@
  */
 /** Validate + decode a 64-char hex key to 32 bytes. Throws on the wrong shape so
  *  a misconfigured key fails loud, never silently weakens encryption. */
-declare function decodeHexKey(keyHex: string): Uint8Array;
+export declare function decodeHexKey(keyHex: string): Uint8Array;
 /** Encrypt `plaintext` with AES-256-GCM under `keyHex`. Returns
  *  base64(iv ‖ ciphertext ‖ tag). A fresh random IV per call. */
-declare function encryptAesGcm(plaintext: string, keyHex: string): Promise<string>;
+export declare function encryptAesGcm(plaintext: string, keyHex: string): Promise<string>;
 /** Decrypt a base64(iv ‖ ciphertext ‖ tag) string under `keyHex`. Throws if the
  *  tag fails (tamper/wrong key). */
-declare function decryptAesGcm(encrypted: string, keyHex: string): Promise<string>;
+export declare function decryptAesGcm(encrypted: string, keyHex: string): Promise<string>;
 /** Build a {@link import('../billing').KeyCrypto}-compatible pair bound to a key
  *  (or a key-resolver, for env-backed keys resolved per call). */
-declare function createFieldCrypto(key: string | (() => string)): {
+export declare function createFieldCrypto(key: string | (() => string)): {
     encrypt(s: string): Promise<string>;
     decrypt(s: string): Promise<string>;
 };
@@ -36,7 +36,7 @@ declare function createFieldCrypto(key: string | (() => string)): {
  * defaults are a sensible baseline; any product supplies its own via
  * {@link DeriveKeyOptions}.
  */
-interface DeriveKeyOptions {
+export interface DeriveKeyOptions {
     /** PBKDF2 salt. A product MUST pin this — changing it changes the derived key
      *  bytes and orphans every value already encrypted at rest. */
     salt: Uint8Array | string;
@@ -47,16 +47,14 @@ interface DeriveKeyOptions {
 }
 /** Derive an AES-256-GCM `CryptoKey` from a secret string via PBKDF2. The key is
  *  non-extractable and usable only for encrypt/decrypt. */
-declare function deriveKey(secret: string, opts: DeriveKeyOptions): Promise<CryptoKey>;
+export declare function deriveKey(secret: string, opts: DeriveKeyOptions): Promise<CryptoKey>;
 /** Encrypt `plaintext` under a derived `CryptoKey`. Returns base64(iv ‖ ct ‖ tag). */
-declare function encryptWithKey(plaintext: string, key: CryptoKey): Promise<string>;
+export declare function encryptWithKey(plaintext: string, key: CryptoKey): Promise<string>;
 /** Decrypt a base64(iv ‖ ct ‖ tag) string under a derived `CryptoKey`. */
-declare function decryptWithKey(encoded: string, key: CryptoKey): Promise<string>;
+export declare function decryptWithKey(encoded: string, key: CryptoKey): Promise<string>;
 /** Encrypt binary data under a derived `CryptoKey`. Returns an ArrayBuffer:
  *  12-byte IV ‖ ciphertext ‖ 16-byte GCM tag (same wire layout as the string
  *  path, raw bytes instead of base64). */
-declare function encryptBytes(data: ArrayBuffer, key: CryptoKey): Promise<ArrayBuffer>;
+export declare function encryptBytes(data: ArrayBuffer, key: CryptoKey): Promise<ArrayBuffer>;
 /** Decrypt binary data (IV ‖ ciphertext ‖ tag) under a derived `CryptoKey`. */
-declare function decryptBytes(data: ArrayBuffer, key: CryptoKey): Promise<ArrayBuffer>;
-
-export { type DeriveKeyOptions, createFieldCrypto, decodeHexKey, decryptAesGcm, decryptBytes, decryptWithKey, deriveKey, encryptAesGcm, encryptBytes, encryptWithKey };
+export declare function decryptBytes(data: ArrayBuffer, key: CryptoKey): Promise<ArrayBuffer>;

package/dist/crypto/web-token.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Dependency-free WebCrypto primitives for HMAC-signed, base64url-encoded
+ * tokens — base64url encode/decode, HMAC-SHA256, and a constant-time compare.
+ * Runs on Cloudflare Workers, Node, and the browser with no Node `crypto`
+ * dependency. Shared by the sandbox terminal-proxy token, the WS-upgrade token
+ * parser, and the app-tool capability token so the logic lives in one place
+ * rather than three near-identical private copies.
+ *
+ * Internal leaf: not exported from the `/crypto` barrel (that subpath is the
+ * AES-GCM field-crypto surface); imported directly by the modules that need it.
+ */
+/** base64url-encode raw bytes (RFC 4648 §5, no padding). */
+export declare function base64UrlEncode(bytes: Uint8Array): string;
+/** base64url-encode a UTF-8 string. */
+export declare function base64UrlEncodeText(text: string): string;
+/** Decode a base64url string back to its UTF-8 text. Re-pads before `atob` so
+ *  unpadded input decodes correctly regardless of the runtime's leniency. */
+export declare function base64UrlDecodeText(value: string): string;
+/** HMAC-SHA256 `message` under `secret`, returned base64url-encoded. */
+export declare function hmacSha256Base64Url(message: string, secret: string): Promise<string>;
+/** Length-independent-leak-free compare of two same-charset strings. */
+export declare function constantTimeEqual(a: string, b: string): boolean;

package/dist/design-canvas/apply.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Pure application of validated scene operations to a SceneDocument.
+ * `applySceneOperations` deep-clones the document then mutates the clone,
+ * returning the new document and per-op results. It never touches the store,
+ * a clock, or a PRNG — all id generation goes through the caller-supplied
+ * `mintId` option so callers control determinism (counter in tests,
+ * crypto.randomUUID in production).
+ *
+ * Rotation semantics for group/ungroup:
+ *   Group: children retain their absolute rotation. The group origin is the
+ *   min-x, min-y corner of the AABB union of all member elements. Children
+ *   are rebased so their position in group-local space equals
+ *   (element.x - group.x, element.y - group.y). A rotated child appears at
+ *   the same absolute page position after grouping because the group's additive
+ *   translation preserves the child's own-origin transform.
+ *   Ungroup: inverse — child.x += group.x, child.y += group.y; rotation stays.
+ *   This is consistent with Konva's transform-about-own-origin model without
+ *   needing a full matrix concatenation for the common case.
+ *
+ * `storeApplyScenePlan` layers store I/O on top: getDocument → validate →
+ * apply → saveDocument(expectedRev) → recordDecision, retrying once on
+ * stale-rev by refetch + revalidate + reapply.
+ */
+import type { SceneDocument, SceneElement, ScenePage } from './model';
+import type { SceneOperation, ScenePlan } from './operations';
+import type { NewSceneDecision, SceneDocumentRecord, SceneStore } from './store';
+/** Represent the result of applying changes to a scene as an element, page, or entire document */
+export type SceneApplyResult = {
+    kind: 'element';
+    pageId: string;
+    element: SceneElement;
+} | {
+    kind: 'page';
+    page: ScenePage;
+} | {
+    kind: 'document';
+};
+/** Resolve element ID conflicts by providing fresh unique identifiers during scene application */
+export interface ApplySceneOptions {
+    /**
+     * Provides fresh ids when duplicate_page re-mints element ids. Never called
+     * by any other operation. Counter-based in tests; crypto.randomUUID in
+     * production (wrapped so `mintId()` has no arguments, matching this signature).
+     */
+    mintId: () => string;
+}
+/** Full form: returns the new document AND per-op results. `mintId` must be
+ *  provided when any operation in the list may be `duplicate_page` (which
+ *  re-mints element ids); for all other operation types it is never called. */
+export declare function applySceneOperations(document: SceneDocument, operations: SceneOperation[], options: ApplySceneOptions): {
+    document: SceneDocument;
+    results: SceneApplyResult[];
+};
+/** Convenience 2-arg form: returns the new document directly. Uses a
+ *  monotonic counter as the mintId so `duplicate_page` never collides within
+ *  a single call (suitable for editor-local optimistic state; server will
+ *  re-mint on persist). */
+export declare function applySceneOperations(document: SceneDocument, operations: SceneOperation[]): SceneDocument;
+/** Apply a single operation to a document and return the new document.
+ *  Equivalent to `applySceneOperations(doc, [op])` but returns `SceneDocument`
+ *  directly — the common case in editor commands and tests. */
+export declare function applySceneOperation(document: SceneDocument, operation: SceneOperation): SceneDocument;
+/** Resolve and apply a scene plan to the store with specified actor context and generate results */
+export declare function storeApplyScenePlan(store: SceneStore, plan: ScenePlan, opts: {
+    actorKind: NewSceneDecision['kind'];
+    mintId: () => string;
+}): Promise<{
+    record: SceneDocumentRecord;
+    results: SceneApplyResult[];
+}>;

package/dist/design-canvas/drizzle-store.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Drizzle-backed `SceneStore` over the tables from `createDesignCanvasTables`.
+ * Works against any SQLite drizzle driver (better-sqlite3, D1, libsql).
+ *
+ * Defense in depth: RBAC runs before the store is constructed, but every
+ * query still pins `workspaceId` AND `documentId` from the scope in its WHERE
+ * clause, so a leaked or attacker-supplied row id from another workspace can
+ * never read or write across the boundary — it surfaces as "not found".
+ *
+ * Optimistic concurrency for saveDocument: the UPDATE WHERE clause includes
+ * `rev = expectedRev`; when 0 rows are changed (stale revision or missing
+ * document), the store reads back the row to emit a precise error — either
+ * "stale rev" or "not found" — so callers know whether to refetch-and-replay
+ * or abort.
+ */
+import type { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
+import type { SceneStore, SceneStoreScope } from './store';
+import type { DesignCanvasTables } from './schema';
+/** Any SQLite drizzle database — `any` erases the driver-specific run-result
+ *  and schema generics so better-sqlite3, D1, and libsql handles all fit. */
+export type DesignCanvasDatabase = BaseSQLiteDatabase<'sync' | 'async', any, any>;
+/** Define options for creating a Drizzle scene store including database, tables, and scope */
+export interface CreateDrizzleSceneStoreOptions {
+    db: DesignCanvasDatabase;
+    tables: DesignCanvasTables;
+    scope: SceneStoreScope;
+}
+/** Create a scene store configured with database tables and scoped to a specific document and workspace */
+export declare function createDrizzleSceneStore(options: CreateDrizzleSceneStoreOptions): SceneStore;