@lapxo/bound 0.1.9 → 0.2.1

package/dist/fold/shards.d.ts

@@ -1,29 +0,0 @@
-export declare const OBSERVED: RegExp;
-export declare const LEVEL: RegExp;
-export declare const readerOf: (line: string) => string | undefined;
-type Latest = {
-    readonly at: string;
-    readonly line: string;
-};
-export declare const trimmed: (where: string) => string;
-export { sha } from '../host/hash.ts';
-/**
- * What a reader said is kept by region: the region a place lies in is the longest a reader's lock names that holds it,
- * the stamps and digests it was observed at are lines of that region's shard, and what the reader answered for the
- * region is one observation, stored under its reader's extension, the region, the digest of the region's places and
- * the resolution it was read at. A fold opens the shards of the regions it reaches and reads each observation by its
- * key: nothing is scanned, the same bytes are never read twice, and an observation found under its key is the reading.
- */
-export declare function regionIn(regions: readonly string[], place: string): string;
-export declare const keyOf: (by: string, region: string, pairs: readonly string[], resolution?: string) => string;
-export declare const observed: (store: string, key: string) => boolean;
-export declare function observation(store: string, key: string): readonly string[] | undefined;
-export declare function keepObservation(store: string, key: string, lines: readonly string[]): void;
-export declare function opened(store: string, speaker: string, region: string, alive: ReadonlySet<string>): {
-    readonly region: string;
-    readonly places: ReadonlyMap<string, Latest>;
-    readonly keys: Map<string, string>;
-};
-export declare const pointer: (speaker: string, by: string, region: string, key: string, pairs: readonly string[]) => string;
-export declare function legacyOf(store: string, speaker: string, regions: readonly string[]): ReadonlyMap<string, readonly string[]> | undefined;
-export declare function setAside(store: string, speaker: string): void;

package/dist/fold/signed.d.ts

@@ -1,23 +0,0 @@
-import { authorityFor } from './signers.ts';
-/** Lines told to a place's own lock for a preview: folded as if the file held them, and standing only as its signed lines do. */
-export declare const tellOwn: (place: string, lines: readonly string[]) => void;
-/**
- * A place's own lock, folded as the tree folds its own: a line that carries a signature stands only when a key the
- * tree's lock admits signed it, inside the window that key held at the epoch it signed and inside its coverage of the
- * place, the line's scope read as a region of the place; a line that carries none is the place's target text until the
- * place signs its lock, and never stands where only signed lines are asked for.
- */
-export declare function ownLockOf(root: string, place: string, signedOnly?: boolean): readonly string[];
-/**
- * What a place's own lock holds by signature — a key the tree admits signed the line, inside its window and its coverage
- * of the place — withdrawal or not: whether one line stands there so, the lines that do, and how many were written into
- * the lock rather than applied to it.
- */
-export declare const admittedIn: (root: string, place: string, line: string) => boolean;
-export declare const appliedIn: (root: string, place: string) => readonly string[];
-export declare const forksIn: (root: string, place: string) => readonly string[];
-export declare const writtenIn: (root: string, place: string) => number;
-/** Authenticated history excludes prospective lines told only for admission. */
-export declare const appliedHistoryIn: (root: string, place: string) => readonly string[];
-/** Shared signature/window/coordinate coverage boundary for own history. */
-export declare function ownRecordAdmitted(line: string, place: string, family: string, signers: ReturnType<typeof authorityFor>['admitted'], algorithms: readonly string[]): boolean;

package/dist/fold/signers.d.ts

@@ -1,24 +0,0 @@
-import type { Published, Signer, SignerVerdict } from '@lapxo/topos/wire';
-/** A lock line about the signers: the authority fold reads it. */
-export declare function isSignerLock(line: string): boolean;
-/** The authority view of a ledger: which signers the lock admits from its root, and what each line carries. */
-export declare function authorityFor(lines: readonly string[], root: Signer, admitted: readonly string[], published?: Published): {
-    readonly admitted: readonly Signer[];
-    readonly potential: readonly string[];
-    readonly of: (line: string) => SignerVerdict;
-};
-/** The key this lock admits for a class of writing: the fold is kept by whoever runs it, and the lock says who that is. */
-export declare function writerFor(standing: readonly string[], kind: string): string | undefined;
-export declare function publicKeyOf(root: string, keyId: string): string | undefined;
-export declare function releaseSigner(lines: readonly string[]): Signer;
-export declare function rootSigner(root: string): {
-    id: string;
-    keyClass: 'authorize';
-    publicKey: string;
-    coverage: string[];
-    depth: {
-        lo: number;
-        hi: number;
-    };
-    admittedBy: string[];
-};

package/dist/fold/stranger.d.ts

@@ -1,3 +0,0 @@
-/** A clone that holds a lock and no ledger: receipts none, one place opened, the needs the lock names, each uses/ pin still open, and README.md to render. Nothing is folded and nothing is written. */
-export declare function emptyLedger(store: string): boolean;
-export declare function sayStranger(root: string): void;

package/dist/fold/views.d.ts

@@ -1,27 +0,0 @@
-interface Asked {
-    readonly name: string;
-    readonly at: number;
-    readonly called?: boolean;
-}
-export interface View {
-    readonly name: string;
-    readonly regions: readonly Asked[];
-    readonly shape: string;
-}
-/**
- * A view is a signed line `view/<name>` whose value lists regions in the order they are written, each at the resolution
- * it asks for (`region@n`, the steps of each line it keeps, three when it asks for none, and the one the view is called
- * at for `region@*`), and whose shape, when it has one, names the coordinate the view renders into. What renders a region is
- * read where the fold is known, and a view asking one nothing renders is refused there, by name.
- */
-export declare function viewsOf(standing: readonly string[]): ReadonlyMap<string, View>;
-/**
- * A view the wire's views/world list names writes at a world that holds no view of that name of its own: the tree's line
- * of the name, at the shape it names. A place's own view of a shape shadows the list at that shape: own over root, one
- * writer. Two views naming the same shape in one place is a refuse at rank, before any render.
- */
-export declare const defaulted: (standing: readonly string[], view: View, own: readonly string[], tree: ReadonlyMap<string, View>) => boolean;
-/** Shapes two standing views of one place both name: rank refuses before a render, one path, one writer. */
-export declare function sharedShapes(standing: readonly string[]): readonly string[];
-export declare function placesOf(standing: readonly string[], view: View): readonly string[];
-export {};

package/dist/fold/wire.d.ts

@@ -1,19 +0,0 @@
-import type { RoleClaim } from '@lapxo/topos/wire';
-export type CoordinateRole = 'source' | 'derived' | 'observed' | 'foreign';
-export declare const namesAt: (at: string, name: string) => boolean;
-export declare const roleAt: (at: string, claims: readonly RoleClaim[]) => CoordinateRole;
-/** The standing line that names a wire list, under `wire/`, else the older `audit/wire/` for one era. A word the wire names is read from the lock by the list it belongs to: the instrument asks for one and refuses if the lock no longer lists it, so an alphabet is never frozen here and a family that moves is a refusal, not a silence. */
-export declare const wireLine: (standing: readonly string[], list: string) => string | undefined;
-export declare function wordsOf(standing: readonly string[], list: string): readonly string[];
-/**
- * A word asked in its eras, newest first, is read in the lock it is asked of: the first era that lock's own wire lists
- * is the word there, so a place published under an older wire is read in the word it was written in, and none is a
- * refusal. A list that names exactly one word is read as that word; a list that names none, or more than one, is a
- * refusal. The older `audit/wire/` prefix is one era of `wire/`, not a fall-back to another lock.
- */
-export declare function wordOf(standing: readonly string[], list: string, name: string | readonly string[]): string;
-export declare function theWord(standing: readonly string[], list: string): string;
-export declare const wordOn: (standing: readonly string[], list: string, fallback: readonly string[]) => string;
-/** A named word, read from the standing that lists it, else from the fallback lock. */
-export declare function wordFrom(standing: readonly string[], list: string, name: string | readonly string[], fallback: readonly string[]): string;
-export declare const said: (lines: readonly string[], scope: string) => readonly string[];

package/dist/fold/zoom.d.ts

@@ -1,16 +0,0 @@
-/**
- * A line of the tree seen from inside a place: every path it names under the place is read from the place's root, and
- * a path outside it is dropped, since the place alone cannot read it. The place's name drops out of the scope, the condition
- * and the policy a line is held at, and a cone names the coordinates it covers the same way; the place itself is `./`. In a
- * scope the name drops out of the step after the family, or after the one word that qualifies it (prose/en, hazard/<kind>,
- * source/<measure>); a deeper step that spells it is inside a name, such as a package a module imports, and stays.
- */
-export declare function zoomed(line: string, place: string): string;
-/** The lines of each place's own lock that still name the place: seen from inside a place, no scope carries its name. */
-export declare function namingTheirPlace(root: string): number;
-/**
- * What a zoom rewrote that is not the place: over each place the lock publishes, every scope and condition of the tree
- * and of the place's receipts that spells the place as a step, zoomed from inside it. Losing the place's step after the
- * family, or after the one word qualifying it, is the zoom; any other rewrite took a value for the place.
- */
-export declare function zoomedOutsideThePlace(root: string, standing: readonly string[]): number;

package/dist/host/act-cost.d.ts

@@ -1,13 +0,0 @@
-/** A sequence of declared acts is not one act. Unpartitioned host work still has a cost. */
-export declare class ActCosts {
-    private readonly began;
-    private occupied;
-    private largest;
-    private depth;
-    private readonly clock;
-    constructor(clock?: () => number);
-    begin(): () => void;
-    measure<T>(work: () => T): T;
-    seconds(): number;
-}
-export declare const actCosts: ActCosts;

package/dist/host/adapters/keys/ed25519.d.ts

@@ -1,7 +0,0 @@
-/**
- * The act of signing: canonical bytes, a private key and the algorithm the wire names for this era in; a signature
- * value out, whose form is the algebra's. The host runs the act and knows no name: which algorithms a signature may
- * carry, this era's and the ones the lines before it were signed under, is told by whoever read the lock.
- */
-export declare const signBytes: (bytes: string, privateKeyPem: string, algorithm: string) => string;
-export declare function verifyBytes(bytes: string, publicKeyPem: string, signature: string, admitted: readonly string[]): boolean;

package/dist/host/adapters/modules/javascript.d.ts

@@ -1,3 +0,0 @@
-export declare function moduleImports(source: string, coordinate: string): readonly string[];
-/** A JavaScript literal value; syntax inventory never executes it. */
-export declare const stringLiteral: (node: unknown) => string | undefined;

package/dist/host/adapters/transport/http.d.ts

@@ -1,5 +0,0 @@
-/** Reference HTTP adapter. Location and budgets are already selected by admitted host policy. */
-export declare function fetchBytes(location: string, limits: {
-    readonly timeoutMs: number;
-    readonly responseBytes: number;
-}): Promise<Uint8Array>;

package/dist/host/admitted-place.d.ts

@@ -1,5 +0,0 @@
-/** Existing admission-snapshot authentication and folded live projection.
- * Consumer configuration evidence only; never a new authority lock. */
-export declare function authenticatedRootStanding(root: string): readonly string[];
-/** Legacy Root lines remain unchanged; contextual public output has its own carrier. */
-export declare const authenticatedStanding: typeof authenticatedRootStanding;

package/dist/host/archive.d.ts

@@ -1,11 +0,0 @@
-export interface Member {
-    readonly name: string;
-    readonly bytes: Uint8Array;
-}
-/** POSIX archive coordinates; normalization cannot make two members share one destination. */
-export declare function archiveCoordinate(name: string): string;
-/** The gzip/POSIX tar adapter reads regular files, directories and PAX attributes, or rejects the whole archive. */
-export declare function members(archive: Uint8Array): readonly Member[];
-/** Existing links or files are never followed or overwritten by extraction. */
-export declare function archiveDestination(into: string, name: string): string;
-export declare function unpack(archive: Uint8Array, into: string): readonly string[];

package/dist/host/capsule-process.d.ts

@@ -1,21 +0,0 @@
-import type { ReaderLifetime } from '@lapxo/topos/wire';
-import type { SpawnSyncOptionsWithStringEncoding } from 'node:child_process';
-import type { Request, Response } from '@lapxo/topos/contract';
-/** Operational process failure, distinct from a valid contract refusal or abstention. */
-export declare class CapsuleProcessError extends Error {
-    readonly stdout: string;
-    readonly stderr: string;
-    readonly status: number | null;
-    readonly signal: NodeJS.Signals | null;
-    readonly cause: unknown;
-    constructor(reason: string, result: {
-        stdout?: string;
-        stderr?: string;
-        status: number | null;
-        signal: NodeJS.Signals | null;
-        error?: unknown;
-    });
-}
-export declare function validResponse(value: unknown, request: Request): value is Response;
-/** Last-line JSON is the wire framing. No partial batch, failed exit or synthetic missing response is accepted. */
-export declare function executeCapsule(command: string, args: readonly string[], requests: readonly Request[], limits?: Pick<SpawnSyncOptionsWithStringEncoding, 'timeout' | 'maxBuffer' | 'env' | 'cwd'>, lifetime?: ReaderLifetime): readonly Response[];

package/dist/host/capsule.d.ts

@@ -1,19 +0,0 @@
-import type { ReaderReference } from '@lapxo/topos/wire';
-import type { Declaration } from '@lapxo/topos/capsule';
-import type { Request, Response } from '@lapxo/topos/contract';
-export interface Capsule {
-    readonly selectedWorld?: {
-        readonly standing: import("@lapxo/topos/standing").StandingTopos;
-        readonly offer: string;
-    };
-    readonly selection?: string;
-    readonly digest: string;
-    readonly declaration: Declaration;
-    readonly lines: readonly string[];
-    readonly ask: (requests: readonly Request[], reader?: ReaderReference) => readonly (Response | undefined)[];
-}
-/** A blob is loaded once in an act. A later ask for the same digest reads that capsule, and does not hash or unpack it again. */
-export declare function capsuleAt(digest: string, entry: string, store?: string): Capsule | undefined;
-export declare const childFlags: (argv?: readonly string[]) => readonly string[];
-/** The host may supply its cache store independently of the located executable. */
-export declare function locatedAt(tree: string, place: string, cacheStore?: string): Capsule | undefined;

package/dist/host/cell-receipts.d.ts

@@ -1,2 +0,0 @@
-/** Native count/bytes receipt lines; carried render blobs are separate verified cache payloads. */
-export declare function cellsWithReceipts(root: string, history: readonly string[], emit: (text: string) => void): Promise<void>;

package/dist/host/content-needed.d.ts

@@ -1,5 +0,0 @@
-/** The synchronous host names unavailable content; the enclosing fold resolves exactly that request. */
-export declare class ContentNeeded extends Error {
-    readonly digest: string;
-    constructor(digest: string, why?: string);
-}

package/dist/host/content-store.d.ts

@@ -1,8 +0,0 @@
-export declare const withContentStore: <T>(store: string, run: () => T, policy?: () => readonly string[]) => T;
-export declare const contentPolicy: () => readonly string[];
-export declare const contentStore: () => string;
-/** Only immutable verified bytes may be shared with the instrument. Local corruption is never hidden by fallback. */
-export declare function verifiedContent(digest: string, store?: string, instrument?: string): {
-    readonly bytes: Uint8Array;
-    readonly path: string;
-};

package/dist/host/contextual-place.d.ts

@@ -1,59 +0,0 @@
-import { type PlaceReceipt } from '@lapxo/topos/core';
-export declare function hasContextualPlace(root: string): boolean;
-/** Exact selected SDK frame plus complete pre-signed receiver statements. No
- * executable/verifier/epoch selection can be supplied by this envelope. */
-export declare function landContextualPlace(root: string, file: string): Promise<import("./ports/place-act.ts").PlaceActBundle & {
-    readonly kind: "landed" | "once";
-    readonly identity: string;
-}>;
-export declare function contextualAct(root: string, identity: string): {
-    profile: string;
-    identity: string;
-    context: string;
-    receipts: readonly PlaceReceipt[];
-    contexts: {
-        identity: string;
-        context: string;
-        receipts: readonly PlaceReceipt[];
-        authority: ReturnType<(encoded: string) => {
-            anchor: import("@lapxo/topos/wire").Signer;
-            history: readonly string[];
-            checkpoint: string;
-        }>;
-    }[];
-} | undefined;
-/** Carriers retain exact originals and authenticated context/receipts. Each
- * namespace folds independently; labels assert no statistical independence. */
-export declare function contextualStanding(root: string): {
-    profile: string;
-    root: readonly string[];
-    legacyPlaces: {
-        namespace: string;
-        place: string;
-        standing: string[];
-        history: readonly string[];
-    }[];
-    contexts: {
-        identity: string;
-        context: string;
-        receipts: readonly PlaceReceipt[];
-        authority: {
-            anchor: import("@lapxo/topos/wire").Signer;
-            history: readonly string[];
-            checkpoint: string;
-        };
-    }[];
-    places: {
-        namespace: string;
-        place: string;
-        standing: string[];
-        retracted: readonly string[];
-        superseded: readonly string[];
-        forks: readonly import("../fold/claims.ts").Fork[];
-        contexts: {
-            identity: string;
-            context: string;
-            receipts: readonly PlaceReceipt[];
-        }[];
-    }[];
-};

package/dist/host/digest.d.ts

@@ -1,3 +0,0 @@
-/** Sorted by UTF-8 bytes; the algorithm is a field (`sha256:…`), never bare hex. */
-export declare function fullDigest(input: string | readonly string[], algorithm: string): string;
-export declare function bytesDigest(bytes: Uint8Array, algorithm: string): string;

package/dist/host/hash.d.ts

@@ -1,9 +0,0 @@
-import { type Hash } from 'node:crypto';
-/** SHA-256 byte hashing for host formats that explicitly name this algorithm. */
-export declare const sha: (bytes: string | Uint8Array) => string;
-/** Typed digest spelling shared by fixed host boundaries; hashes identical bytes. */
-export declare const sha256: (bytes: string | Uint8Array) => string;
-/** Length-delimited UTF-8 fields for existing host history identities. */
-export declare function hashText(hash: Hash, value: string): void;
-/** Exact typed SHA-256 spelling used by fixed host declarations. */
-export declare const isSha256: (value: unknown) => value is string;

package/dist/host/io.d.ts

@@ -1,11 +0,0 @@
-/** The host's node surface: kernel folders import here, never `node:`. World reads still go through observeFile. */
-export { spawn, spawnSync } from 'node:child_process';
-export { createHash } from 'node:crypto';
-export { appendFileSync, closeSync, existsSync, linkSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync, } from 'node:fs';
-export { tmpdir } from 'node:os';
-export { basename, dirname, join, relative, resolve } from 'node:path';
-export { fileURLToPath } from 'node:url';
-export { parentPort, workerData } from 'node:worker_threads';
-export { gzipSync } from 'node:zlib';
-/** UTF-8 encoding for host byte formats. */
-export declare const encodeUTF8: (text: string) => Uint8Array;

package/dist/host/lifetime.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/host/located.d.ts

@@ -1,4 +0,0 @@
-type Module = Readonly<Record<string, unknown>>;
-export declare const locate: (root: string, dir: string, ext: string) => Promise<Module>;
-export declare const load: () => Promise<Module>;
-export {};

package/dist/host/native/bounded-file.d.ts

@@ -1,8 +0,0 @@
-/** The opened descriptor is bounded before allocation/read. Growth after fstat
- * is detected with one sentinel byte; no oversized buffer reaches decode/hash.
- */
-export declare function readBoundedFile(path: string, remaining: number, coordinate: string): Buffer;
-export declare function readBoundedBatch(paths: readonly {
-    path: string;
-    coordinate: string;
-}[], budget: number): readonly Buffer[];

package/dist/host/native/command.d.ts

@@ -1,36 +0,0 @@
-import type { CommandPort, CommandLot } from '@lapxo/topos/contract';
-type Phase = 'selection' | 'help' | 'check' | 'preview' | 'sign' | 'act';
-export interface Invocation {
-    readonly command: string;
-    readonly args: readonly string[];
-    readonly cwd: string;
-    readonly hostEnvelope?: Uint8Array;
-    readonly envelopeBytes?: number;
-}
-export interface HostBoundary {
-    readonly admitsDeclaration: (port: CommandPort) => boolean;
-    readonly covers: (coordinate: string) => boolean;
-    readonly verifies: (digest: string) => boolean;
-    /** Host chooses a verified invocation. A capsule cannot supply a program. */
-    readonly resolve: (port: CommandPort) => Invocation;
-    /** Independent loader-closure proof, not a digest-list membership test. */
-    readonly loaderClosure: (port: CommandPort, invocation: Invocation) => 'verified' | 'unmeasured';
-}
-/** macOS prototype: bounded async invocation with POSIX child-group cancellation.
- * No acquisition or persistence on prospective paths; no partial success frames.
- * Host callbacks are trusted admission/verification operations, never signatures
- * or authority assertions supplied by the command's own output. */
-export declare function executeLot(options: {
-    port: CommandPort;
-    lot: CommandLot;
-    host: HostBoundary;
-    phase: Phase;
-    environment: Readonly<Record<string, string>>;
-    signal?: AbortSignal;
-    accepts: (member: unknown, index: number) => boolean;
-}): Promise<{
-    readonly members: readonly unknown[];
-    readonly stderr: string;
-    readonly invocations: 1;
-}>;
-export {};

package/dist/host/native/control-bridge-worker.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/host/native/control-bridge.d.ts

@@ -1,30 +0,0 @@
-export interface ControlEndpoint {
-    readonly socket: string;
-    readonly timeoutMs: number;
-    readonly deadlineMs: number;
-    readonly responseBytes: number;
-}
-export interface FixedControlBinding {
-    readonly endpoint: ControlEndpoint;
-    readonly workerBytes: Uint8Array;
-    readonly worker: {
-        readonly digest: string;
-        readonly coordinate: string;
-        readonly bytes: number;
-    };
-    readonly runtime: {
-        readonly path: string;
-        readonly digest: string;
-        readonly bytes: number;
-    };
-    readonly resources: {
-        readonly inputBytes: number;
-        readonly outputBytes: number;
-        readonly sharedBytes: number;
-    };
-    readonly deadlineMs: number;
-}
-export declare function createFixedControlBridge(inputBinding: FixedControlBinding): {
-    exchange(frame: string): string;
-    close(): Promise<void>;
-};

package/dist/host/native/control-selection.d.ts

@@ -1,29 +0,0 @@
-import { type RootStanding, type PortProfile } from './reading.ts';
-export interface HostControlProfile {
-    readonly profile: 'host-control-transport@1';
-    readonly realm: 'main-thread';
-    readonly coordinate: string;
-    readonly selector: {
-        readonly port: string;
-        readonly implementation: string;
-    };
-    readonly worker: {
-        readonly coordinate: string;
-        readonly digest: string;
-        readonly bytes: number;
-    };
-    readonly runtime: {
-        readonly coordinate: string;
-        readonly digest: string;
-    };
-    readonly limits: {
-        readonly workersPerProcess: 1;
-        readonly inFlight: 1;
-        readonly sharedBytes: number;
-    };
-}
-export interface HostControlSelection {
-    readonly line: string;
-    readonly profile: HostControlProfile;
-}
-export declare function selectedHostControl(root: RootStanding, parent: PortProfile): HostControlSelection | undefined;

package/dist/host/native/custody.d.ts

@@ -1,5 +0,0 @@
-import { type RootStanding, type PortProfile } from './reading.ts';
-import type { RootJobCustody, NodeImage } from './node-jobs.ts';
-import type { Handoff } from './jobs.ts';
-import type { LogicalLoader } from './image.ts';
-export declare function nativeRootJobCustody(root: RootStanding, profile: PortProfile, handoff: Handoff, image: NodeImage, logical: LogicalLoader): RootJobCustody;

package/dist/host/native/deadline.d.ts

@@ -1,12 +0,0 @@
-/** Remaining monotonic lease, rounded up for host APIs that accept milliseconds. */
-export declare function remainingDeadlineMs(deadline: bigint): number;
-interface Clock {
-    readonly now: () => bigint;
-    readonly schedule: (callback: () => void, delayMs: number) => unknown;
-    readonly cancel: (handle: unknown) => void;
-}
-/** The admitted deadline is never clamped to the platform timer range. Each
- * timer is merely a wake-up slice; expiry checks the original monotonic clock.
- * Injected clock exists only for deterministic platform-boundary vectors. */
-export declare function scheduleDeadline(deadline: bigint, expire: () => void, clock?: Clock): () => void;
-export {};

package/dist/host/native/descendants.d.ts

@@ -1 +0,0 @@
-export declare function installDescendantBoundary(config: any): void;

package/dist/host/native/generated-custodian.d.ts

@@ -1,122 +0,0 @@
-import { type NativeBinaryProjection } from './native-binary.ts';
-import { type GeneratedProducer, type LiteralSnapshot, type DescendantInvocation, type ProducerLimits, type ProducerCandidates } from './generated.ts';
-import { type NativeEvalActual } from './node-launch.ts';
-export interface ProducerEndpoint {
-    socket: string;
-    token: string;
-    coordinate: string;
-    implementation: string;
-    identity: string;
-    timeoutMs: number;
-    deadlineMs: number;
-    responseBytes: number;
-    interpretations: readonly string[];
-    limits: Readonly<ProducerLimits>;
-}
-/** Refusal transport is bounded too; an undersized channel closes without a
- * frame while the parent retains the named refusal. No truncation is success. */
-export declare function boundedRefusalFrame(endpoint: ProducerEndpoint, why: string): string | undefined;
-export interface EntryRequest {
-    candidates?: readonly ProducerCandidates[];
-    kind: 'file' | 'eval';
-    path?: string;
-    interpretation?: string;
-    mode: 'module' | 'commonjs';
-    argv?: readonly string[];
-    rootPrefix?: readonly string[];
-    invocation: DescendantInvocation;
-}
-export interface NativeProgramGrant {
-    readonly identity: string;
-    readonly program: NativeBinaryProjection;
-}
-export interface NativeProgramRequest {
-    alias: string;
-    path: string;
-    invocation: DescendantInvocation;
-}
-export interface EmissionBatchRequest {
-    outputs: readonly {
-        path: string;
-        digest: string;
-    }[];
-    invocation: DescendantInvocation;
-}
-export interface EmissionRequest {
-    path: string;
-    invocation: DescendantInvocation;
-}
-export interface InterpretationRequest {
-    path: string;
-    interpretation: string;
-    invocation: DescendantInvocation;
-}
-export declare function startProducerCustodian(handle: GeneratedProducer, snapshot: LiteralSnapshot, nativeImplementations: ReadonlySet<string>, directory: string, inputNativePrograms?: readonly NativeProgramGrant[]): Promise<{
-    endpoint: ProducerEndpoint;
-    readonly contexts: any[];
-    retention: () => {
-        bytes: number;
-        contexts: any[];
-        values: any[][];
-    };
-    assertClosed: () => void;
-    refusals: string[];
-    usage: () => Readonly<{
-        members: number;
-        bytes: number;
-        work: number;
-        retainedContents: number;
-        codeBytes: number;
-        limits: {
-            members: number;
-            bytes: number;
-            work: number;
-            argvBytes: number;
-            argvItems: number;
-        };
-    }>;
-    close: () => Promise<void>;
-}>;
-/** Asynchronous client for original async native APIs. Original sync APIs use
- * the fixed client executable; both address this SAME custodian/counters. */
-export declare function requestRetainedEvalContext(endpoint: ProducerEndpoint, actual: NativeEvalActual): Promise<any>;
-export declare function requestProducerEntry(endpoint: ProducerEndpoint, request: EntryRequest): Promise<any>;
-export declare function requestProducerInterpretation(endpoint: ProducerEndpoint, request: InterpretationRequest): Promise<any>;
-export declare function requestNativeProgram(endpoint: ProducerEndpoint, request: NativeProgramRequest): Promise<any>;
-export declare function requestProducerEmission(endpoint: ProducerEndpoint, request: EmissionRequest): Promise<any>;
-export declare function requestProducerEmissionBatch(endpoint: ProducerEndpoint, request: EmissionBatchRequest): Promise<any>;
-/** Bound's guarded host constructs this factory, not a world. The transport path
- * is selected by the sealed native preload configuration, not a grant in data.
- * A shared context file cannot be multiplexed across simultaneous bindings. */
-export declare function createProducerJobCustody(input: {
-    root: import('./reading.ts').RootStanding;
-    coordinate: string;
-    implementationBytes: Uint8Array;
-    snapshot: LiteralSnapshot;
-    nativeImplementations: ReadonlySet<string>;
-    directory: string;
-    contextFile: string;
-    nativeBinaries?: readonly {
-        coordinate: string;
-        privateBinding: {
-            coordinate: string;
-            path: string;
-            digest: string;
-        };
-    }[];
-    programSelections?: readonly {
-        coordinate: string;
-        runtimeBinding: {
-            coordinate: string;
-            path: string;
-            digest: string;
-            members: readonly {
-                coordinate: string;
-                path: string;
-            }[];
-        };
-    }[];
-}): import('./node-jobs.ts').RootJobCustody;
-/** Fixed Root preload reports a local before-entry refusal to the SAME parent
- * custodian. A caught child error therefore cannot become a success receipt. */
-export declare function reportProducerViolation(endpoint: ProducerEndpoint, why: string): Promise<never>;