@lapxo/bound 0.2.0 → 0.2.1

package/dist/fold/region.d.ts

@@ -1,72 +0,0 @@
-import type { Interval } from '@lapxo/obligations/forms';
-/**
- * A region is a prefix of the place, read at a resolution: the prefixes a lock already names — the steps a role, a
- * directory or a need is given at — are its regions, a cell belongs to the longest of them that holds it, and a region
- * rests on the region its prefix extends. A signature or a requirement is a line at the region its scope names, never a
- * value copied into the cells there; a cell's poles are the meet of the live bounds on its chain of rest, met in the
- * lattice of their form. Each region carries a summary of what lies in it, summed over the regions that rest on it —
- * cells, the sums and the values they read at the lattice's own resolution, the bounds signed at it — so what a bound
- * would bite is read off a summary without visiting a cell, and two readings of one place differ exactly in the regions
- * whose summaries differ. Nothing here is kept between folds; a region is read from the lines that stand and the cells seen.
- */
-export interface Bound {
-    readonly line: string;
-    readonly question: string;
-    readonly region: string;
-    readonly measure: string;
-    readonly form: string;
-    readonly value: string;
-}
-export interface Regions {
-    readonly named: readonly string[];
-    readonly bounds: readonly Bound[];
-    readonly summaries: ReadonlyMap<string, {
-        readonly region: string;
-        readonly cells: number;
-        readonly sums: ReadonlyMap<string, number>;
-        readonly values: ReadonlyMap<string, ReadonlyMap<string, number>>;
-        readonly bounds: readonly Bound[];
-    }>;
-}
-export declare function regionsNamed(standing: readonly string[]): readonly string[];
-export declare function boundOf(named: readonly string[], line: string): Bound;
-/**
- * The poles of a region, question by question: each live bound is signed at the region it names and travels by rest, as
- * the object signs, so the ceiling is what the region reads up its chain of rest, the meet in the lattice of their form, and beside it what the region's cells hold under that question,
- * value by count. Read off the summaries alone; no cell is visited.
- */
-export declare function polesOf(regions: Regions, region: string): ReadonlyMap<string, {
-    readonly ceiling: Interval | readonly string[] | undefined;
-    readonly held: ReadonlyMap<string, number> | undefined;
-}>;
-export declare function regionsOf(standing: readonly string[], ceilings: readonly string[], cells: readonly {
-    readonly question: string;
-    readonly measure: string;
-    readonly value: string;
-    readonly place: string;
-}[]): Regions;
-/**
- * What a bound bites, read off the summary of its region and never off a cell: the values its region's cells read that
- * lie outside it, and of those the ones every bound above it still admits. A question finer than a summary is not asked.
- */
-export declare function rankOf(regions: Regions, bound: Bound, own?: Readonly<Record<string, number>>): {
-    readonly bars: number;
-    readonly cells: number;
-    readonly fresh: number;
-    readonly met: number;
-    readonly sums: number;
-};
-export declare function finerOf(regions: Regions): ReadonlyMap<string, readonly string[]>;
-export declare function digestsOf(regions: Regions): ReadonlyMap<string, string>;
-export declare function differing(a: Regions, b: Regions): {
-    readonly regions: readonly string[];
-    readonly compared: number;
-};
-export interface Packed {
-    readonly named: readonly string[];
-    readonly bounds: readonly string[];
-    readonly summaries: readonly (readonly [string, number, readonly (readonly [string, number])[], readonly (readonly [string, readonly (readonly [string, number])[]])[]])[];
-}
-export declare const packRegions: (regions: Regions) => Packed;
-export declare function unpackRegions(packed: Packed): Regions;
-export declare function unlikeReplay(regions: Regions, red: ReadonlySet<string>, own: Readonly<Record<string, number>>): number;

package/dist/fold/release-policy.d.ts

@@ -1,67 +0,0 @@
-import type { VerdictDemand, VerdictObservation } from '@lapxo/topos/authority';
-type CeilingReading = {
-    readonly read: readonly string[];
-    readonly unread: readonly string[];
-    readonly vacuous: readonly string[];
-    readonly over: readonly {
-        readonly ceiling: string;
-        readonly question: string;
-        readonly got: string;
-        readonly side: 'short' | 'over';
-    }[];
-};
-export interface ReleasePolicyInput {
-    /** Standing already admitted by the same fold. This function does not admit lines. */
-    readonly verdicts?: readonly VerdictObservation[];
-    readonly standing: readonly string[];
-    readonly demands: readonly string[];
-    readonly paid: readonly string[];
-    readonly ceilings: readonly string[];
-    readonly readings: CeilingReading;
-    readonly snapshot: {
-        readonly fold: string;
-        readonly instrument: string;
-    };
-    readonly faults?: readonly {
-        readonly kind: string;
-        readonly evidence: readonly string[];
-        readonly obligation?: string;
-    }[];
-}
-export interface ReleasePolicyResult {
-    readonly gates?: readonly VerdictDemand[];
-    readonly status: 'absent' | 'incomplete' | 'blocked' | 'ready';
-    readonly snapshot: ReleasePolicyInput['snapshot'];
-    readonly policy: readonly string[];
-    readonly categories: readonly {
-        readonly name: string;
-        readonly links: readonly string[];
-        readonly selected: readonly string[];
-        readonly failures: readonly {
-            readonly line: string;
-            readonly reason: string;
-            readonly evidence: readonly string[];
-        }[];
-    }[];
-    readonly unresolved: readonly string[];
-    /** All obligations, including those not selected; the normal fold keeps their verdicts. */
-    readonly debt: readonly string[];
-}
-/** Preserve actual fold faults; none gets a release category from its spelling. */
-export declare function releaseFaults(fold: {
-    readonly forks: readonly {
-        readonly key: string;
-        readonly lines: readonly string[];
-    }[];
-    readonly refused: readonly string[];
-    readonly grey: readonly string[];
-    readonly orphans: readonly string[];
-    readonly second: {
-        readonly verdict: string;
-    };
-}): NonNullable<ReleasePolicyInput['faults']>;
-/** Select declared obligations, never categories inferred from their names or paths. */
-export declare function releasePolicy(input: ReleasePolicyInput): ReleasePolicyResult;
-/** Existing fold output can show the policy without a new view or a release action. */
-export declare function releasePolicyLines(result: ReleasePolicyResult | undefined): readonly string[];
-export {};

package/dist/fold/resolved.d.ts

@@ -1,18 +0,0 @@
-import type { PlaceFold } from '../cli/place.ts';
-export declare const bytesOnly: (line: string) => string;
-/**
- * Every receipt of a place, @8: the bytes of what it observed that a reading ran over, those readings, the verdicts its
- * paid demands were taken with, and at the root the digest of each place's own receipts. The attest is none of them:
- * it stands in the root lock and the release, naming the root these lines resolve to. The fold keeps the set in the
- * root's store under the digest of its bytes, which every line that resolves it names, and what a place with no reader
- * carries is read back from there, never from a file the place ships.
- */
-export declare function receiptsOf(fold: PlaceFold): readonly string[];
-export declare function keepCarried(store: string, lines: readonly string[], from?: string): string;
-/**
- * What a copy of a place reads back of its receipts: the lines it shipped when they are the whole set, or, when they
- * name a root at the digest of its bytes, the set the store keeps there; a root the store does not keep is no set, and
- * the caller refuses rather than read the lines that only name it.
- */
-export declare function carriedFrom(store: string, shipped: readonly string[]): readonly string[] | undefined;
-export declare const carriedIn: (store: string) => readonly string[];

package/dist/fold/roles.d.ts

@@ -1,17 +0,0 @@
-import type { RoleClaim } from '@lapxo/topos/wire';
-import type { CoordinateRole } from './wire.ts';
-/** A lock line that gives a coordinate its role: every walk of the tree reads it. */
-export declare function isRoleLock(line: string): boolean;
-/** A lock the owner signs by digest and a capsule writes: its lines stand while the bytes are the ones that were signed. */
-export declare function inheritedRoles(store: string): {
-    readonly claims: readonly RoleClaim[];
-    readonly stale: readonly string[];
-};
-/**
- * What each coordinate of the tree is: the capsule that knows a world writes the roles of that world, the owner signs the
- * capsule's lock by digest, and this fold reads both. The instrument reads claims and never a name, and a coordinate no
- * standing claim names is source. The steps a walk must not enter are read the same way: the claims that name a whole
- * folder foreign or derived, as a set the walk can ask in one step instead of matching every claim at every step.
- */
-export declare function stepsOutside(store: string): ReadonlySet<string>;
-export declare function rolesOf(store: string): (coordinate: string) => CoordinateRole;

package/dist/fold/second.d.ts

@@ -1,18 +0,0 @@
-export interface SecondHead {
-    /** What its latest word says of this fold: the same lines stand, other lines stand, it read another ledger, its key is not admitted, or it never spoke. */
-    readonly verdict: 'agrees' | 'forks' | 'stale' | 'grey' | 'none';
-    /**
-     * A head counts as an origin of its own only once it has disagreed: until then it may be this one again (L16); and
-     * the epoch of its latest word, wherever it said it, which a clone reads as history and not as its own.
-     */
-    readonly external: boolean;
-    readonly epoch: number;
-    readonly apart?: readonly string[];
-}
-/**
- * The second head's word, read against this fold. It attests the digest of the lines it found standing and the digest
- * of the lines of the ledger it folded, in whatever order a store landed them, so a clone that lands the same lines
- * agrees; agreement is an encounter, disagreement a fork. A word about another lock is not read as this one's: the head
- * bound's own lock names is asked now over the ledger as it stands, with no key, and what it says is read, never kept.
- */
-export declare function secondHead(store: string, standing: readonly string[], admitted: (line: string) => boolean, owned?: readonly string[]): SecondHead;

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 {};