@zackbart/connecta 0.28.1 → 0.30.0

package/dist/runtime/storage.js

@@ -17,7 +17,7 @@
 // runtime holds, because createConnecta passes the same two objects to both.
 // A scoped view holds no storage of its own: it reaches Storage through the
 // registry it delegates to, and the result stash is always the root's,
-// because its capacity is runtime-wide.
+// because its capacity is deployment-wide.
 import { Context, Effect } from "effect";
 import { runEdge } from "./run.js";
 import { Logger, Storage } from "./services.js";
@@ -44,6 +44,13 @@ export function storageDelete(key) {
         catch: (error) => error,
     }));
 }
+/** Atomic compare-and-set of one key, as `KVStorage.compareAndSet`. */
+export function storageCompareAndSet(key, expected, next, options) {
+    return Storage.use((storage) => Effect.tryPromise({
+        try: () => Promise.resolve(storage.compareAndSet(key, expected, next, options)),
+        catch: (error) => error,
+    }));
+}
 // One context per partition object, built on first use. A registry's options
 // object lives exactly as long as the registry, so the WeakMap never holds a
 // partition past its owner.

package/dist/sent-secrets.d.ts

@@ -0,0 +1,93 @@
+import type { ConnectorContext, JsonSchema, Logger } from "./types.js";
+/** One payload-free warning per configured connector, regardless of requests. */
+export declare function shortSecretWarning(): (value: string | undefined, logger: Logger) => void;
+export declare class SentSecrets {
+    /** Normalized form to its strongest kind. */
+    private readonly forms;
+    private readonly recipients;
+    private privateChars;
+    /** The shortest form left unregistered; any string this long might contain it. */
+    private unmatched;
+    private unicode;
+    private views;
+    private store;
+    private unregistered;
+    private register;
+    /** The request receives existing and future secrets from every context. */
+    include(source: SentSecrets): void;
+    add(value: string): void;
+    /** Explicit secrets use the same floor as every other credential. */
+    secret(value: string): void;
+    /** Submitted writeOnly strings and numbers join this request's set, including property
+     * names inside a private object. Empty strings, booleans, and null carry no text. */
+    arguments(args: unknown, schema: JsonSchema | undefined): void;
+    /** Structural fields must be refused, never repaired into different URLs. */
+    contains(value: string, ignoreCase?: boolean): boolean;
+    containsUrl(value: string): boolean;
+    header(value: string): void;
+    request(input: RequestInfo | URL, init?: RequestInit): void;
+    /** Serialized wire text about to be returned, stored, or paged, under payload rules. */
+    text(value: string): string;
+    /** Copy only what changes, including non-enumerable Error fields; never retain a raw cause.
+     * Payload rules apply where downstream or guest data enters; envelopes repeat literal
+     * replacement. */
+    redact<T>(value: T, mode?: "payload" | "prose" | "envelope"): T;
+    /** Credentials alone: later calls keep the private arguments they submit, and cached
+     * catalogs never depend on one request's arguments. */
+    redactCredentials<T>(value: T): T;
+    private idle;
+    private scan;
+    private matcher;
+    private credentials;
+    /** Strings at least this long might hold a form that was never matched. */
+    private floor;
+    /** Every raw and JSON-unescaped match, mapped to source spans before any replacement. Text
+     * decodes one more layer while the last one could still hold an escape, up to
+     * MAX_DECODE_LEVELS counting the JSON strings it came from. Work beyond the call's budget
+     * or that depth returns undefined, which withholds the string. */
+    private find;
+    /** A structured leaf, property name, or prose. A short private form withholds prose
+     * wherever it occurs, and a leaf only when the whole leaf is that form. */
+    private string;
+    /** A number, boolean, or null matching by its canonical text becomes a placeholder string. */
+    private scalar;
+    /** JSON objects, arrays, and string literals are parsed and walked, nested JSON strings
+     * included; their serialized bytes must then hold no literal the walk cannot see, such as
+     * one spanning tokens. Other text is prose or a structured leaf. */
+    private wire;
+    /** Iterative and copy-on-write: only containers on a changed path are copied. A container's
+     * entries are counted against the node budget before it is walked; a cycle or a container
+     * past MAX_WALK_DEPTH is withheld, and one past the node budget is checked as serialized text. */
+    private walk;
+    /** A container larger than the node budget is scanned as serialized text, Error fields
+     * included: kept unchanged when nothing registered appears, otherwise withheld whole. */
+    private serialized;
+    /** Skill supporting files may contain arbitrary bytes, including echoes. */
+    private blob;
+    /** Match across blocks before isError/JSON unwrapping concatenates them. */
+    private joinedContent;
+}
+export declare function sentSecretsFor(ctx: ConnectorContext): SentSecrets;
+/** One identity per upstream request, including all discovery and call work. */
+export declare function sentSecretsForRequest(scope: object, secrets?: SentSecrets): SentSecrets;
+/** The agent-facing choke point. Apply to values before bridge serialization
+ * and to serialized wire text, so JSON escapes and structured strings share
+ * the same rule. Payloads were redacted where they entered; this boundary
+ * repeats credential and literal private-value replacement around Connecta's
+ * own envelopes, whose identifiers and counts are never private data. */
+export declare function redactAgentOutput<T>(secrets: SentSecrets, value: T): T;
+/** Wrap the complete operation table, including rejections. Adding an operation
+ * cannot add an unredacted exit. A direct invocation owns a fresh scope unless
+ * its HTTP request supplied one. */
+export declare function agentOutputOperations<T extends Record<string, (...args: never[]) => Promise<unknown>>>(create: (scope: object) => T, requestScope?: object): T;
+/** Slot reads cover custom handlers too, including keys put in query strings. */
+export declare function trackCredentialReads(ctx: ConnectorContext): void;
+export declare function redactSentSecrets<T>(ctx: ConnectorContext, value: T): T;
+/** Sanitize listing facts before any cache or consumer receives them. A name
+ * cannot be rewritten without changing dispatch, and dropping one entry would
+ * publish a partial catalog, so refuse the complete listing instead. */
+export declare function redactCatalog<T extends {
+    name: string;
+}>(ctx: ConnectorContext, tools: T[]): T[];
+/** Register only after the transport has assembled the request it sends. */
+export declare function sentSecretsFetch(ctx: ConnectorContext, send?: typeof fetch): typeof fetch;