@timurproko/a1 0.1.8-dev.50ebb19 → 0.1.8-dev.510

package/dist/src/foundation/structured-agent-runtime/backpressure.js

@@ -1,118 +0,0 @@
-import { assertStructuredCapability, } from "../workspace-contracts/index.js";
-export class StructuredBackpressureController {
-    adapterId;
-    #budgets;
-    #usage = {
-        events: { units: 0, bytes: 0 },
-        commands: { units: 0, bytes: 0 },
-        snapshots: { units: 0, bytes: 0 },
-        attachments: { units: 0, bytes: 0 },
-        "reconnect-replay": { units: 0, bytes: 0 },
-    };
-    #leases = new Map();
-    #nextLeaseSequence = 0;
-    #replayExhausted = false;
-    constructor(adapterId, capability) {
-        this.adapterId = adapterId;
-        assertStructuredCapability(capability);
-        if (!adapterId || adapterId !== capability.adapterId)
-            throw new TypeError("structured backpressure adapter identity is invalid");
-        this.#budgets = Object.freeze({
-            events: budget(capability.flow.maxQueuedEvents, capability.flow.maxQueuedEvents * capability.flow.maxEventBytes, capability.flow.maxEventBytes, "pause-adapter"),
-            commands: budget(capability.flow.maxConcurrentCommands, capability.flow.maxConcurrentCommands * capability.flow.maxEventBytes, capability.flow.maxEventBytes, "reject-request"),
-            snapshots: budget(1, capability.flow.maxSnapshotBytes, capability.flow.maxSnapshotBytes, "reject-request"),
-            attachments: budget(capability.flow.maxConcurrentCommands, capability.flow.maxAttachmentBytes, capability.flow.maxAttachmentBytes, "reject-request"),
-            "reconnect-replay": budget(capability.flow.maxReconnectEvents, capability.flow.maxReconnectEvents * capability.flow.maxEventBytes, capability.flow.maxEventBytes, "disconnect-adapter"),
-        });
-    }
-    acquire(resource, units = 1, bytes = 0) {
-        const budget = this.#budget(resource);
-        if (!isPositiveSafeInteger(units) || !isSafeNonNegativeInteger(bytes)) {
-            return this.#reject(resource, "invalid-request", "reject-request", "resource units and bytes must be bounded safe integers");
-        }
-        if (bytes > budget.perPayloadByteLimit) {
-            return this.#reject(resource, "payload-too-large", "reject-payload", `${resource} payload exceeds its negotiated ${budget.perPayloadByteLimit} byte limit`);
-        }
-        if (resource === "reconnect-replay" && this.#replayExhausted) {
-            return this.#reject(resource, "replay-exhausted", "disconnect-adapter", "reconnect replay is already exhausted for this adapter");
-        }
-        const usage = this.#usage[resource];
-        if (usage.units + units > budget.unitLimit || usage.bytes + bytes > budget.byteLimit) {
-            if (resource === "reconnect-replay") {
-                this.#replayExhausted = true;
-                return this.#reject(resource, "replay-exhausted", "disconnect-adapter", "reconnect replay exceeded its negotiated event or byte window");
-            }
-            return this.#reject(resource, "resource-exhausted", budget.action, `${resource} exceeded its negotiated count or byte window`);
-        }
-        usage.units += units;
-        usage.bytes += bytes;
-        this.#nextLeaseSequence += 1;
-        const lease = Object.freeze({
-            id: `lease-${this.adapterId}-${this.#nextLeaseSequence}`,
-            resource,
-            units,
-            bytes,
-        });
-        this.#leases.set(lease.id, lease);
-        return { kind: "accepted", lease, usage: this.usage(resource) };
-    }
-    release(lease) {
-        if (!lease || typeof lease.id !== "string" || !isPositiveSafeInteger(lease.units) || !isSafeNonNegativeInteger(lease.bytes)) {
-            return { kind: "rejected", code: "invalid-request", diagnostic: "resource lease is malformed" };
-        }
-        const owned = this.#leases.get(lease.id);
-        if (!owned || owned.resource !== lease.resource || owned.units !== lease.units || owned.bytes !== lease.bytes) {
-            return { kind: "rejected", code: "unknown-lease", diagnostic: `resource lease is unknown: ${lease.id}` };
-        }
-        this.#leases.delete(lease.id);
-        const usage = this.#usage[lease.resource];
-        usage.units -= lease.units;
-        usage.bytes -= lease.bytes;
-        return { kind: "released", usage: this.usage(lease.resource) };
-    }
-    resetReconnectReplay() {
-        const usage = this.#usage["reconnect-replay"];
-        usage.units = 0;
-        usage.bytes = 0;
-        this.#replayExhausted = false;
-        for (const [id, lease] of this.#leases) {
-            if (lease.resource === "reconnect-replay")
-                this.#leases.delete(id);
-        }
-    }
-    usage(resource) {
-        const usage = this.#usage[resource];
-        const budget = this.#budget(resource);
-        return Object.freeze({
-            resource,
-            units: usage.units,
-            bytes: usage.bytes,
-            unitLimit: budget.unitLimit,
-            byteLimit: budget.byteLimit,
-        });
-    }
-    leaseCount() {
-        return this.#leases.size;
-    }
-    replayExhausted() {
-        return this.#replayExhausted;
-    }
-    #budget(resource) {
-        const budget = this.#budgets[resource];
-        if (!budget)
-            throw new TypeError(`unknown structured backpressure resource: ${String(resource)}`);
-        return budget;
-    }
-    #reject(resource, code, action, diagnostic) {
-        return { kind: "rejected", code, action, usage: this.usage(resource), diagnostic };
-    }
-}
-function budget(unitLimit, byteLimit, perPayloadByteLimit, action) {
-    return Object.freeze({ unitLimit, byteLimit, perPayloadByteLimit, action });
-}
-function isPositiveSafeInteger(value) {
-    return Number.isSafeInteger(value) && value > 0;
-}
-function isSafeNonNegativeInteger(value) {
-    return Number.isSafeInteger(value) && value >= 0;
-}

package/dist/src/foundation/structured-agent-runtime/commands.d.ts

@@ -1,52 +0,0 @@
-import { type StructuredCapabilityContract, type WorkspaceCommand } from "../workspace-contracts/index.js";
-export type StructuredCommandRequest = Extract<WorkspaceCommand, {
-    readonly type: "structured-command";
-}>;
-export type StructuredCancelRequest = Extract<WorkspaceCommand, {
-    readonly type: "cancel-structured-command";
-}>;
-export type StructuredCommandTerminalOutcome = "completed" | "failed" | "timed-out" | "cancelled";
-export interface StructuredCommandRecord {
-    readonly agentId: string;
-    readonly correlationId: string;
-    readonly command: string;
-    readonly payload: unknown;
-    readonly startedAt: number;
-    readonly terminalAt: number | null;
-    readonly outcome: "active" | StructuredCommandTerminalOutcome;
-    readonly revision: number;
-}
-export type StructuredCommandStartResult = {
-    readonly kind: "accepted";
-    readonly record: StructuredCommandRecord;
-    readonly activeCount: number;
-} | {
-    readonly kind: "outcome";
-    readonly record: StructuredCommandRecord;
-    readonly idempotent: true;
-} | {
-    readonly kind: "rejected";
-    readonly code: string;
-    readonly diagnostic: string;
-};
-export type StructuredCommandOutcomeResult = {
-    readonly kind: "outcome";
-    readonly record: StructuredCommandRecord;
-    readonly idempotent: boolean;
-} | {
-    readonly kind: "rejected";
-    readonly code: string;
-    readonly diagnostic: string;
-};
-export declare class StructuredCommandTracker {
-    #private;
-    readonly agentId: string;
-    constructor(agentId: string, capability: StructuredCapabilityContract, commandTimeoutMs?: number);
-    start(command: StructuredCommandRequest, startedAt?: number): StructuredCommandStartResult;
-    complete(correlationId: string, outcome: "completed" | "failed", completedAt?: number): StructuredCommandOutcomeResult;
-    cancel(request: StructuredCancelRequest, cancelledAt?: number): StructuredCommandOutcomeResult;
-    expire(now: number): readonly StructuredCommandRecord[];
-    outcomeFor(correlationId: string): StructuredCommandRecord | null;
-    activeCount(): number;
-    terminalCount(): number;
-}

package/dist/src/foundation/structured-agent-runtime/commands.js

@@ -1,164 +0,0 @@
-import { assertStructuredCapability, assertWorkspaceCommand, } from "../workspace-contracts/index.js";
-export class StructuredCommandTracker {
-    agentId;
-    #capability;
-    #commandTimeoutMs;
-    #records = new Map();
-    #terminalOrder = [];
-    constructor(agentId, capability, commandTimeoutMs = 30_000) {
-        this.agentId = agentId;
-        assertStructuredCapability(capability);
-        if (!agentId || agentId.includes("\0"))
-            throw new TypeError("structured command agent id is invalid");
-        if (!Number.isSafeInteger(commandTimeoutMs) || commandTimeoutMs <= 0)
-            throw new RangeError("structured command timeout must be positive");
-        this.#capability = capability;
-        this.#commandTimeoutMs = commandTimeoutMs;
-    }
-    start(command, startedAt = 0) {
-        try {
-            assertWorkspaceCommand(command);
-        }
-        catch (error) {
-            return rejected("malformed-command", error);
-        }
-        if (command.agentId !== this.agentId)
-            return rejected("agent-mismatch", new Error("structured command agent does not match the tracker identity"));
-        if (!this.#capability.commands.includes(command.command)) {
-            return rejected("unsupported-command", new Error(`structured command is not negotiated: ${command.command}`));
-        }
-        if (payloadBytes(command.payload) > this.#capability.flow.maxEventBytes) {
-            return rejected("command-too-large", new Error(`structured command exceeds the negotiated ${this.#capability.flow.maxEventBytes} byte payload limit`));
-        }
-        try {
-            assertTime(startedAt, "command start time");
-        }
-        catch (error) {
-            return rejected("invalid-time", error);
-        }
-        const existing = this.#records.get(command.correlationId);
-        if (existing) {
-            if (existing.outcome !== "active" && existing.command === command.command && stableJson(existing.payload) === stableJson(command.payload)) {
-                return { kind: "outcome", record: freezeRecord(existing), idempotent: true };
-            }
-            return rejected(existing.outcome === "active" ? "duplicate-correlation" : "correlation-conflict", new Error(`structured correlation id is already in use: ${command.correlationId}`));
-        }
-        if (this.activeCount() >= this.#capability.flow.maxConcurrentCommands) {
-            return rejected("concurrency-limit", new Error(`structured command concurrency exceeds the negotiated ${this.#capability.flow.maxConcurrentCommands} command limit`));
-        }
-        const record = {
-            agentId: command.agentId,
-            correlationId: command.correlationId,
-            command: command.command,
-            payload: command.payload,
-            startedAt,
-            terminalAt: null,
-            outcome: "active",
-            revision: 1,
-        };
-        this.#records.set(record.correlationId, record);
-        return { kind: "accepted", record: freezeRecord(record), activeCount: this.activeCount() };
-    }
-    complete(correlationId, outcome, completedAt = 0) {
-        if (outcome !== "completed" && outcome !== "failed")
-            return rejected("malformed-outcome", new Error("structured completion outcome is invalid"));
-        try {
-            assertTime(completedAt, "command completion time");
-        }
-        catch (error) {
-            return rejected("invalid-time", error);
-        }
-        const record = this.#records.get(correlationId);
-        if (!record)
-            return rejected("unknown-correlation", new Error(`structured correlation id is unknown: ${correlationId}`));
-        return this.#settle(record, outcome, completedAt);
-    }
-    cancel(request, cancelledAt = 0) {
-        try {
-            assertWorkspaceCommand(request);
-        }
-        catch (error) {
-            return rejected("malformed-cancellation", error);
-        }
-        if (request.agentId !== this.agentId)
-            return rejected("agent-mismatch", new Error("structured cancellation agent does not match the tracker identity"));
-        if (this.#capability.cancellation !== "correlated")
-            return rejected("cancellation-unsupported", new Error("the negotiated adapter capability does not support correlated cancellation"));
-        try {
-            assertTime(cancelledAt, "command cancellation time");
-        }
-        catch (error) {
-            return rejected("invalid-time", error);
-        }
-        const record = this.#records.get(request.targetCorrelationId);
-        if (!record)
-            return rejected("unknown-correlation", new Error(`structured correlation id is unknown: ${request.targetCorrelationId}`));
-        return this.#settle(record, "cancelled", cancelledAt);
-    }
-    expire(now) {
-        assertTime(now, "command timeout clock");
-        const expired = [];
-        for (const record of this.#records.values()) {
-            if (record.outcome === "active" && now - record.startedAt >= this.#commandTimeoutMs) {
-                const result = this.#settle(record, "timed-out", record.startedAt + this.#commandTimeoutMs);
-                if (result.kind === "outcome")
-                    expired.push(result.record);
-            }
-        }
-        return Object.freeze(expired);
-    }
-    outcomeFor(correlationId) {
-        const record = this.#records.get(correlationId);
-        return record ? freezeRecord(record) : null;
-    }
-    activeCount() {
-        let count = 0;
-        for (const record of this.#records.values())
-            if (record.outcome === "active")
-                count += 1;
-        return count;
-    }
-    terminalCount() {
-        return this.#terminalOrder.length;
-    }
-    #settle(record, outcome, at) {
-        if (record.outcome !== "active")
-            return { kind: "outcome", record: freezeRecord(record), idempotent: true };
-        if (at < record.startedAt)
-            return rejected("invalid-time", new Error("structured command outcome cannot precede its start"));
-        record.outcome = outcome;
-        record.terminalAt = at;
-        record.revision += 1;
-        this.#terminalOrder.push(record.correlationId);
-        this.#boundTerminalOutcomes();
-        return { kind: "outcome", record: freezeRecord(record), idempotent: false };
-    }
-    #boundTerminalOutcomes() {
-        const retention = this.#capability.flow.maxQueuedEvents;
-        while (this.#terminalOrder.length > retention) {
-            const oldest = this.#terminalOrder.shift();
-            if (oldest === undefined)
-                return;
-            this.#records.delete(oldest);
-        }
-    }
-}
-function rejected(code, error) {
-    return { kind: "rejected", code, diagnostic: error instanceof Error ? error.message : String(error) };
-}
-function freezeRecord(record) {
-    return Object.freeze({ ...record });
-}
-function assertTime(value, name) {
-    if (!Number.isSafeInteger(value) || value < 0)
-        throw new RangeError(`${name} must be a non-negative safe integer`);
-}
-function payloadBytes(payload) {
-    return new TextEncoder().encode(stableJson(payload)).byteLength;
-}
-function stableJson(value) {
-    const encoded = JSON.stringify(value);
-    if (encoded === undefined)
-        throw new TypeError("structured payload must be JSON serializable");
-    return encoded;
-}

package/dist/src/foundation/structured-agent-runtime/handshake.d.ts

@@ -1,41 +0,0 @@
-import { type AdapterId, type StructuredCapabilityContract, type StructuredFlowLimits } from "../workspace-contracts/index.js";
-export declare const STRUCTURED_ADAPTER_ENVELOPE: string;
-export declare const STRUCTURED_ADAPTER_ENVELOPE_REVISION: 1;
-export declare const REQUIRED_STRUCTURED_FEATURES: readonly ["identity.adapter.v1", "commands.correlated.v1", "events.typed.v1", "flow-control.limits.v1"];
-export declare const OPTIONAL_STRUCTURED_FEATURES: readonly ["snapshots.authoritative.v1", "resume.position.v1", "resume.snapshot.v1", "commands.cancellable.v1", "attachments.typed.v1"];
-export type StructuredProtocolFeature = typeof REQUIRED_STRUCTURED_FEATURES[number] | typeof OPTIONAL_STRUCTURED_FEATURES[number];
-export declare const STRUCTURED_FLOW_LIMITS: StructuredFlowLimits;
-export interface StructuredAdapterHello {
-    readonly envelope: typeof STRUCTURED_ADAPTER_ENVELOPE;
-    readonly envelopeRevision: typeof STRUCTURED_ADAPTER_ENVELOPE_REVISION;
-    readonly adapterId: AdapterId;
-    readonly buildId: string;
-    readonly requiredFeatures: readonly string[];
-    readonly optionalFeatures: readonly string[];
-    readonly capability: StructuredCapabilityContract;
-}
-export interface StructuredAdapterPeerHello {
-    readonly envelope: typeof STRUCTURED_ADAPTER_ENVELOPE;
-    readonly envelopeRevision: typeof STRUCTURED_ADAPTER_ENVELOPE_REVISION;
-    readonly requiredFeatures: readonly string[];
-    readonly optionalFeatures: readonly string[];
-    readonly flowLimits: StructuredFlowLimits;
-}
-export type StructuredHandshakeErrorCode = "invalid-message" | "unsupported-version" | "invalid-identity" | "invalid-capability" | "unsupported-feature" | "incompatible-features";
-export interface StructuredHandshakeAccepted {
-    readonly accepted: true;
-    readonly adapterId: AdapterId;
-    readonly negotiatedFeatures: readonly string[];
-    readonly capability: StructuredCapabilityContract;
-    readonly diagnostic: string;
-}
-export interface StructuredHandshakeRejected {
-    readonly accepted: false;
-    readonly code: StructuredHandshakeErrorCode;
-    readonly missingFromAdapter: readonly string[];
-    readonly missingFromServer: readonly string[];
-    readonly diagnostic: string;
-}
-export type StructuredHandshakeResult = StructuredHandshakeAccepted | StructuredHandshakeRejected;
-export declare function localStructuredAdapterHello(): StructuredAdapterPeerHello;
-export declare function negotiateStructuredAdapter(value: unknown, server?: StructuredAdapterPeerHello): StructuredHandshakeResult;

package/dist/src/foundation/structured-agent-runtime/handshake.js

@@ -1,151 +0,0 @@
-import { WORKSPACE_CONTRACT_VERSION, assertStructuredCapability, } from "../workspace-contracts/index.js";
-import { PRODUCT_IDENTITY, PRODUCT_TEXT } from "../../product-identity.js";
-export const STRUCTURED_ADAPTER_ENVELOPE = PRODUCT_IDENTITY.protocol.structuredAgentSchema;
-export const STRUCTURED_ADAPTER_ENVELOPE_REVISION = 1;
-export const REQUIRED_STRUCTURED_FEATURES = [
-    "identity.adapter.v1",
-    "commands.correlated.v1",
-    "events.typed.v1",
-    "flow-control.limits.v1",
-];
-export const OPTIONAL_STRUCTURED_FEATURES = [
-    "snapshots.authoritative.v1",
-    "resume.position.v1",
-    "resume.snapshot.v1",
-    "commands.cancellable.v1",
-    "attachments.typed.v1",
-];
-export const STRUCTURED_FLOW_LIMITS = Object.freeze({
-    maxEventBytes: 64 * 1024,
-    maxSnapshotBytes: 1024 * 1024,
-    maxAttachmentBytes: 2 * 1024 * 1024,
-    maxQueuedEvents: 256,
-    maxConcurrentCommands: 4,
-    maxReconnectEvents: 1024,
-});
-export function localStructuredAdapterHello() {
-    return {
-        envelope: STRUCTURED_ADAPTER_ENVELOPE,
-        envelopeRevision: STRUCTURED_ADAPTER_ENVELOPE_REVISION,
-        requiredFeatures: REQUIRED_STRUCTURED_FEATURES,
-        optionalFeatures: OPTIONAL_STRUCTURED_FEATURES,
-        flowLimits: STRUCTURED_FLOW_LIMITS,
-    };
-}
-export function negotiateStructuredAdapter(value, server = localStructuredAdapterHello()) {
-    if (!isStructuredAdapterHello(value)) {
-        return reject("invalid-message", [], [], "adapter hello is malformed or omits required identity, feature, or capability fields");
-    }
-    if (value.envelope !== server.envelope || value.envelopeRevision !== server.envelopeRevision) {
-        return reject("unsupported-version", [], [], `structured adapter envelope mismatch: adapter ${String(value.envelope)}/${String(value.envelopeRevision)}; ${PRODUCT_TEXT.displayName} ${server.envelope}/${server.envelopeRevision}`);
-    }
-    if (!isValidIdentityText(value.adapterId) || !isValidBuildId(value.buildId)) {
-        return reject("invalid-identity", [], [], "adapter identity and build identity must be bounded non-empty values");
-    }
-    if (value.capability.adapterId !== value.adapterId) {
-        return reject("invalid-identity", [], [], "adapter capability identity must match the hello identity");
-    }
-    try {
-        assertStructuredCapability(value.capability);
-    }
-    catch (error) {
-        return reject("invalid-capability", [], [], `adapter capability is invalid: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    const advertised = featureSet(value.requiredFeatures, value.optionalFeatures);
-    if (advertised.error)
-        return advertised.error;
-    const serverFeatures = new Set([...server.requiredFeatures, ...server.optionalFeatures]);
-    const adapterRequired = new Set(value.requiredFeatures);
-    const unknownRequired = [...adapterRequired].filter(feature => !serverFeatures.has(feature));
-    if (unknownRequired.length > 0) {
-        return reject("unsupported-feature", [], unknownRequired.sort(), `adapter requires unsupported structured features: ${unknownRequired.sort().join(", ")}`);
-    }
-    const missingFromAdapter = server.requiredFeatures.filter(feature => !advertised.features.has(feature)).sort();
-    const missingFromServer = [...adapterRequired].filter(feature => !serverFeatures.has(feature)).sort();
-    if (missingFromAdapter.length > 0 || missingFromServer.length > 0) {
-        return reject("incompatible-features", missingFromAdapter, missingFromServer, `required structured features are unavailable; adapter missing [${missingFromAdapter.join(", ")}], ${PRODUCT_TEXT.displayName} missing [${missingFromServer.join(", ")}]`);
-    }
-    const capabilityFeatures = requiredFeaturesForCapability(value.capability);
-    const undeclared = capabilityFeatures.filter(feature => !advertised.features.has(feature));
-    if (undeclared.length > 0) {
-        return reject("invalid-capability", undeclared.sort(), [], `adapter capability requires undeclared features: ${undeclared.sort().join(", ")}`);
-    }
-    const negotiatedFeatures = [...advertised.features].filter(feature => serverFeatures.has(feature)).sort();
-    const capability = {
-        ...value.capability,
-        adapterId: value.adapterId,
-        flow: negotiateFlow(value.capability.flow, server.flowLimits),
-    };
-    return {
-        accepted: true,
-        adapterId: value.adapterId,
-        negotiatedFeatures,
-        capability,
-        diagnostic: `structured adapter ready; negotiated ${negotiatedFeatures.join(", ")}`,
-    };
-}
-function requiredFeaturesForCapability(capability) {
-    const features = [];
-    if (capability.snapshots === "authoritative")
-        features.push("snapshots.authoritative.v1");
-    if (capability.resume === "position")
-        features.push("resume.position.v1");
-    if (capability.resume === "snapshot")
-        features.push("resume.snapshot.v1");
-    if (capability.cancellation === "correlated")
-        features.push("commands.cancellable.v1");
-    if (capability.attachmentTypes.length > 0)
-        features.push("attachments.typed.v1");
-    return features;
-}
-function negotiateFlow(adapter, server) {
-    return Object.freeze({
-        maxEventBytes: Math.min(adapter.maxEventBytes, server.maxEventBytes),
-        maxSnapshotBytes: Math.min(adapter.maxSnapshotBytes, server.maxSnapshotBytes),
-        maxAttachmentBytes: Math.min(adapter.maxAttachmentBytes, server.maxAttachmentBytes),
-        maxQueuedEvents: Math.min(adapter.maxQueuedEvents, server.maxQueuedEvents),
-        maxConcurrentCommands: Math.min(adapter.maxConcurrentCommands, server.maxConcurrentCommands),
-        maxReconnectEvents: Math.min(adapter.maxReconnectEvents, server.maxReconnectEvents),
-    });
-}
-function isStructuredAdapterHello(value) {
-    if (!isRecord(value))
-        return false;
-    return typeof value.envelope === "string"
-        && typeof value.envelopeRevision === "number"
-        && typeof value.adapterId === "string"
-        && typeof value.buildId === "string"
-        && isStringArray(value.requiredFeatures)
-        && isStringArray(value.optionalFeatures)
-        && isRecord(value.capability)
-        && value.capability.kind === "structured"
-        && typeof value.capability.protocolVersion === "number";
-}
-function featureSet(required, optional) {
-    const features = new Set();
-    for (const feature of [...required, ...optional]) {
-        if (!isValidIdentityText(feature)) {
-            return { features, error: reject("invalid-message", [], [], `structured feature name is invalid: ${feature}`) };
-        }
-        if (features.has(feature)) {
-            return { features, error: reject("invalid-message", [], [], `structured feature is declared more than once: ${feature}`) };
-        }
-        features.add(feature);
-    }
-    return { features, error: null };
-}
-function reject(code, missingFromAdapter, missingFromServer, diagnostic) {
-    return { accepted: false, code, missingFromAdapter, missingFromServer, diagnostic };
-}
-function isValidIdentityText(value) {
-    return value.length > 0 && value.length <= 128 && !value.includes("\0");
-}
-function isValidBuildId(value) {
-    return value.length > 0 && value.length <= 256 && !value.includes("\0");
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null;
-}
-function isStringArray(value) {
-    return Array.isArray(value) && value.every(item => typeof item === "string");
-}

package/dist/src/foundation/structured-agent-runtime/index.d.ts

@@ -1,5 +0,0 @@
-export * from "./backpressure.js";
-export * from "./commands.js";
-export * from "./handshake.js";
-export * from "./reconnection.js";
-export * from "./state.js";

package/dist/src/foundation/structured-agent-runtime/index.js

@@ -1,5 +0,0 @@
-export * from "./backpressure.js";
-export * from "./commands.js";
-export * from "./handshake.js";
-export * from "./reconnection.js";
-export * from "./state.js";

package/dist/src/foundation/structured-agent-runtime/reconnection.d.ts

@@ -1,37 +0,0 @@
-import { type AgentRecoveryAuthority, type StructuredAgentSnapshot, type StructuredCapabilityContract, type StructuredRecoveryAuthority } from "../workspace-contracts/index.js";
-import { StructuredEventReducer, type StructuredRuntimeView } from "./state.js";
-export interface StructuredResumeProof {
-    readonly protocolVersion: number;
-    readonly agentId: string;
-    readonly adapterId: string;
-    readonly processIdentity: string;
-    readonly ownershipProof: string;
-    readonly boundary: {
-        readonly kind: "position";
-        readonly position: number;
-        readonly resumeToken: string;
-    } | {
-        readonly kind: "snapshot";
-        readonly snapshotId: string;
-        readonly snapshot: StructuredAgentSnapshot;
-    };
-}
-export type StructuredReconnectionResult = {
-    readonly kind: "accepted";
-    readonly boundary: StructuredRecoveryAuthority["boundary"];
-    readonly view: StructuredRuntimeView | null;
-    readonly diagnostic: string;
-} | {
-    readonly kind: "terminated";
-    readonly reason: "non-reconnectable";
-    readonly diagnostic: string;
-} | {
-    readonly kind: "rejected";
-    readonly code: string;
-    readonly diagnostic: string;
-};
-export declare class StructuredReconnectionManager {
-    #private;
-    constructor(capability: StructuredCapabilityContract);
-    resume(authorityValue: AgentRecoveryAuthority, proof: StructuredResumeProof, reducer?: StructuredEventReducer | null): StructuredReconnectionResult;
-}