@lapxo/bound 0.2.4 → 0.2.6

package/dist/host/in-process-context.d.ts

@@ -1,46 +0,0 @@
-import type { ContentReadPort } from '../engine/ports.ts';
-import type { RootStandingHostContext } from './in-process.ts';
-/** Full contextual carrier, authenticated against receiver inputs only. It is a
- * data projection, not a current admission permit or a signed receipt. */
-export declare function readContextualStandingInProcess(context: RootStandingHostContext, ports: {
-    readonly read: ContentReadPort;
-}): Promise<{
-    kind: "fact";
-    value: {
-        place: string;
-        standing: {
-            profile: string;
-            root: readonly string[];
-            legacyPlaces: {
-                namespace: string;
-                place: string;
-                standing: string[];
-                history: readonly string[];
-            }[];
-            contexts: readonly import("./root-clock-source.ts").PortablePlaceContext[];
-            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 import("@lapxo/topos/wire").PlaceReceipt[];
-                }[];
-            }[];
-        };
-        reading: string;
-        result: string;
-        commitment: string;
-    };
-    code?: undefined;
-    diagnostic?: undefined;
-} | {
-    kind: "refuse";
-    code: string;
-    diagnostic: string;
-    value?: undefined;
-}>;

package/dist/host/in-process-root.d.ts

@@ -1,117 +0,0 @@
-import { type ReadingIdentityContext } from '@lapxo/topos/contract';
-import { type ContentReadPort, type SigningPort, type PortLimits } from '../engine/ports.ts';
-import { type HostInstrumentRuntime } from './call-context.ts';
-import type { LocalActBundle } from './ports/local-act.ts';
-import type { PublicationStorage } from './ports/publication.ts';
-export interface RootLotContext {
-    readonly place: string;
-    readonly snapshot: string;
-    readonly source: string;
-    readonly digest: string;
-    readonly reading: ReadingIdentityContext;
-    readonly limits: PortLimits & {
-        readonly records: number;
-    };
-    readonly signal?: AbortSignal;
-}
-/** The receiver selects the actual native place, instrument and signer. The lot
- * supplies only canonical unsigned Root configuration, never host capabilities. */
-export interface RootLotPorts {
-    readonly root: string;
-    readonly instrumentName: string;
-    readonly runtime: HostInstrumentRuntime;
-    readonly read: ContentReadPort;
-    readonly signer: {
-        readonly keyId: string;
-        readonly name: string;
-        readonly sign: SigningPort;
-    };
-    readonly storage?: PublicationStorage;
-    readonly prepared?: (identity: string) => void;
-    readonly limits: RootLotContext['limits'] & {
-        readonly diagnostics: number;
-    };
-}
-/** Snapshot identity, not a new wire, authority algorithm or current permit. */
-export declare const rootLotSnapshot: (root: string) => string;
-export declare function landRootLotInProcess(context: RootLotContext, ports: RootLotPorts): Promise<{
-    kind: "refuse";
-    code: string;
-    diagnostics: {
-        stream: "out" | "error";
-        text: string;
-    }[];
-    value?: undefined;
-    identity?: undefined;
-    diagnostic?: undefined;
-} | {
-    kind: "fact";
-    value: {
-        result: string;
-        commitment: string;
-        conformance: "refused" | "complete";
-        reading: string;
-        identity?: string | undefined;
-        act?: import("@lapxo/topos/wire").ActResult | undefined;
-        place: string;
-        status: "once" | "landed" | "already-held";
-    };
-    diagnostics: {
-        stream: "out" | "error";
-        text: string;
-    }[];
-    code?: undefined;
-    identity?: undefined;
-    diagnostic?: undefined;
-} | {
-    kind: "uncertain";
-    identity: string;
-    code: string;
-    diagnostic: string;
-    diagnostics: {
-        stream: "out" | "error";
-        text: string;
-    }[];
-    value?: undefined;
-} | {
-    kind: "fact";
-    value: {
-        place: string;
-        status: "once" | "landed";
-        identity: string;
-        conformance: "incomplete";
-    };
-    diagnostic: string;
-    diagnostics: {
-        stream: "out" | "error";
-        text: string;
-    }[];
-    code?: undefined;
-    identity?: undefined;
-} | {
-    kind: "refuse";
-    code: string;
-    diagnostic: string;
-    diagnostics: {
-        stream: "out" | "error";
-        text: string;
-    }[];
-    value?: undefined;
-    identity?: undefined;
-}>;
-/** Authenticated historical query only; never revives authority or signs. */
-export declare function recoverRootActInProcess(identity: string, ports: Pick<RootLotPorts, 'root' | 'instrumentName' | 'runtime'>): {
-    kind: "fact";
-    value: {
-        historical: true;
-        act: import("@lapxo/topos/wire").ActResult;
-        bundle: LocalActBundle;
-    };
-    code?: undefined;
-    diagnostic?: undefined;
-} | {
-    kind: "refuse";
-    code: string;
-    diagnostic: string;
-    value?: undefined;
-};

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

@@ -1,41 +0,0 @@
-import type { Signer } from '@lapxo/topos/wire';
-import type { ReadingIdentityContext } from '@lapxo/topos/contract';
-import type { ContentReadPort, PortLimits } from '../engine/ports.ts';
-/** Initial read-only host slice. The receiver supplies the original anchor and
- * verified implementation/policy references; the offered bytes choose none of them.
- * Context references commit identity, not authority or conformance certification.
- */
-export interface RootStandingHostContext {
-    readonly place: string;
-    readonly source: string;
-    readonly snapshot: string;
-    readonly anchor: Signer;
-    readonly reading: ReadingIdentityContext;
-    readonly limits: PortLimits & {
-        readonly records: number;
-    };
-    readonly signal?: AbortSignal;
-}
-export type RootStandingHostResult = {
-    readonly kind: 'fact';
-    readonly value: {
-        readonly place: string;
-        readonly rootStanding: readonly string[];
-        readonly reading: string;
-        readonly result: string;
-        readonly commitment: string;
-    };
-} | {
-    readonly kind: 'refuse';
-    readonly code: string;
-    readonly diagnostic: string;
-};
-/** Uses the existing bounded content port, authority evaluator and projection.
- * It projects the Root component of a complete signed Root wire snapshot; it has no persistence callback,
- * current-root global, console output, process entry point or CLI subprocess.
- * Contextual places and their carriers are not this Root-only projection.
- * The returned commitment is unsigned and is not a paid native receipt.
- */
-export declare function readRootStandingInProcess(context: RootStandingHostContext, ports: {
-    readonly read: ContentReadPort;
-}): Promise<RootStandingHostResult>;

package/dist/host/native/module-closure.d.ts

@@ -1,35 +0,0 @@
-export interface ModuleClosureMember {
-    readonly digest: string;
-    readonly source: string;
-}
-export interface ModuleClosureSnapshot {
-    readonly identity: string;
-    readonly entry: string;
-    readonly members: ReadonlyMap<string, ModuleClosureMember>;
-}
-export interface ModuleClosureReading {
-    readonly snapshot: string;
-    readonly coordinate: string;
-    readonly digest: string;
-}
-export interface ModuleClosureLimits {
-    readonly members: number;
-    readonly bytes: number;
-    readonly portableESM?: boolean;
-    readonly signal?: AbortSignal;
-}
-/** Host-selected archive and entry, never a verifier assertion from the program.
- * This proves content identity only; standing admission and runtime capabilities
- * are separate prerequisites. Binary resources are not executable text members.
- */
-export declare function moduleSnapshot(archive: Uint8Array, expected: string, entry: string): ModuleClosureSnapshot;
-/** The host supplies authenticated snapshot identities and its library resolver.
- * Each reached text member is verified here against its exact UTF-8 bytes.
- * Authentication of the snapshot envelope remains a separate host prerequisite.
- * A capsule cannot select either verifier or resolver.
- * This reads declared module edges, not arbitrary I/O or a JavaScript sandbox. Computed edges are unpaid, never absent.
- * Activation requires an admitted host policy; existing inventory callers are not silently changed.
- */
-export declare function moduleClosure(snapshot: ModuleClosureSnapshot, library: (specifier: string, parent: ModuleClosureSnapshot) => ModuleClosureSnapshot | undefined): readonly ModuleClosureReading[];
-/** Multiple needs share the existing traversal and one optional act budget. */
-export declare function moduleClosures(snapshots: readonly ModuleClosureSnapshot[], library: (specifier: string, parent: ModuleClosureSnapshot) => ModuleClosureSnapshot | undefined, limits?: ModuleClosureLimits): readonly ModuleClosureReading[];

package/dist/host/native-receiver.d.ts

@@ -1,19 +0,0 @@
-import { type HostInstrumentRuntime } from './call-context.ts';
-export interface NativeHostInstrument {
-    readonly name: string;
-    readonly runtime: HostInstrumentRuntime;
-}
-/** Explicit installed/source ESM selection, never consumer argv or packet data.
- * Identity and public configuration do not certify implementation correctness. */
-export declare function nativeHostInstrument(root: string, entry: string): NativeHostInstrument;
-/** Bind existing native authority construction to an explicit instrument for
- * every later current/historical observation, not only the constructor call. */
-export declare function nativePlaceActReceiver(root: string, instrument: NativeHostInstrument): {
-    selection: import("./place-clock-selection.ts").HostClockSelection;
-    trust: {
-        current: () => import("./ports/place-act.ts").PlaceActSnapshot;
-        historical: (encoded: string) => import("@lapxo/topos/wire").TrustedClockContract;
-        contract: import("@lapxo/topos/wire").TrustedClockContract;
-        initialHeads: readonly import("./ports/place-act.ts").PlaceActHead[];
-    };
-};

package/dist/host/place-act-transaction.d.ts

@@ -1,24 +0,0 @@
-import { type PlaceReceipt } from '@lapxo/topos/core';
-import type { PlaceActTrust, PlaceActBudget, PlaceActBundle, PlaceActHead } from './ports/place-act.ts';
-export { ActCommitUnknown as PlaceActCommitUnknown } from './commit-result.ts';
-/** Host-selected persistence, never supplied by offered content. exclusive must
- * share the CLI's region/authority/projection protocol. publish is synchronous
- * with exactly one atomic visibility point; a thrown reply may follow commit. */
-export interface PlaceActPersistence {
-    readonly exclusive: <T>(regions: readonly string[], run: () => Promise<T>) => Promise<T>;
-    readonly result: (identity: string, trust: PlaceActTrust, limits: PlaceActBudget) => PlaceActBundle | undefined;
-    readonly inventory: (limits: PlaceActBudget) => {
-        readonly names: readonly string[];
-        readonly bytes: number;
-    };
-    readonly heads: (trust: PlaceActTrust, limits: PlaceActBudget) => readonly PlaceActHead[];
-    readonly publish: (identity: string, files: Readonly<Record<string, string>>) => void;
-}
-export type PlaceActReceiptSource = readonly PlaceReceipt[] | (() => Promise<readonly PlaceReceipt[]>);
-/** Shared transaction, including historical replay, current authorization and
- * atomic publication. Signing may await; current Root and receiver heads are
- * checked again afterwards while the same exclusion remains held. */
-export declare function transactPlaceAct(encoded: string, source: PlaceActReceiptSource, trust: PlaceActTrust, limits: PlaceActBudget, persistence: PlaceActPersistence, signal?: AbortSignal): Promise<PlaceActBundle & {
-    readonly kind: 'landed' | 'once';
-    readonly identity: string;
-}>;

package/dist/host/place-clock-selection.d.ts

@@ -1,55 +0,0 @@
-import { PLACE_ACT_CONTEXT, type ClockBudget, type TrustedClockContract } from '@lapxo/topos/core';
-import { type Signer } from '@lapxo/topos/wire';
-import { type PlaceActTrust, type PlaceActBudget, type PlaceActHead } from './ports/place-act.ts';
-export interface HostClockSelection {
-    readonly profile: typeof PLACE_ACT_CONTEXT;
-    readonly namespace: string;
-    readonly regionFamily: string;
-    readonly receiptSigner: string;
-    readonly receiptScope: string;
-    readonly digestAlgorithm: 'sha256';
-    readonly budget: ClockBudget;
-    readonly storageBudget: PlaceActBudget;
-    readonly initial: readonly {
-        place: string;
-        receiver: {
-            identity: string;
-            epoch: string;
-        };
-        origin: {
-            prefix: string;
-            epoch: string;
-        };
-    }[];
-}
-export interface HostClockInput {
-    readonly store: string;
-    readonly selector: string;
-    readonly profileSelector: string;
-    readonly history: readonly string[];
-    readonly anchor: Signer;
-    readonly algorithms: readonly string[];
-    readonly legacyOriginals: readonly string[];
-    /** Actual protected Root authority cursor: an authenticated signed Root config
-     * checkpoint, never a sibling receipt/evidence max epoch. */
-    readonly authorityCheckpoint: string;
-    /** Fixed host historical predecessor proof, never taken from a packet. */
-    readonly authenticatedReceiverHeads?: readonly PlaceActHead[];
-    readonly readCurrent: () => Pick<HostClockInput, 'history' | 'anchor' | 'algorithms' | 'legacyOriginals' | 'authorityCheckpoint'>;
-    readonly resources: {
-        bytes: number;
-        lines: number;
-        places: number;
-    };
-    readonly inherited: {
-        clock: ClockBudget;
-        storage: PlaceActBudget;
-    };
-    readonly historical: (encoded: string) => TrustedClockContract;
-}
-/** Root chooses selector and anchors/resources from its authenticated standing.
- * Selection must be ROOT signed; a world's signature grants no host capability. */
-export declare function hostClockSelection(input: HostClockInput): {
-    selection: HostClockSelection;
-    trust: PlaceActTrust;
-};

package/dist/host/ports/local-act.d.ts

@@ -1,44 +0,0 @@
-import type { PublicationStorage } from './publication.ts';
-/** Prepared and verified by the selected Topos admission/result contract. */
-export interface LocalActBundle {
-    readonly records: string;
-    readonly receipt: string;
-    readonly placements?: readonly {
-        place: string;
-        records: string;
-    }[];
-}
-export type LocalActVerification = (identity: string, bundle: LocalActBundle) => boolean;
-export declare const actLines: (bytes: string) => readonly string[];
-/** Journal integrity is not authority. Signature/coverage checks remain the
- * same admission boundary; the hash algorithm here is the stored seal's named
- * algorithm, not a new selection of the place's wire.
- */
-export declare function intactLocalAct(identity: string, bundle: LocalActBundle): boolean;
-/** Internal integrity key only, not an act identity or a wire profile. */
-export declare function committedInventoryFingerprint(rows: readonly {
-    identity: string;
-    bundle: LocalActBundle;
-}[]): string;
-/** Committed segments are part of this ledger, not a second authority source. */
-export declare function committedLocalActs(store: string): readonly {
-    identity: string;
-    bundle: LocalActBundle;
-}[];
-/** Fixed host observation only: one synchronous, coherent committed inventory.
- * It supplies no authority, verifier or async lifetime. Each outer invocation
- * rereads exact bodies before entering; current authorization still runs inside.
- */
-export declare function withCommittedLocalActObservation<T>(store: string, body: () => T): T;
-/** A public result is available only as a verified committed pair.
- * No writer-tail guess, newest-result selection or implicit authority.
- */
-export declare function localActResult(store: string, identity: string, verify: LocalActVerification): LocalActBundle | undefined;
-/** One publication point for records and their native result. Re-delivery
- * reads the original pair without preparation, signing or a new local epoch.
- * The caller must also integrate this boundary into admission-history readers;
- * this storage port alone does not activate a grammar or land authority.
- */
-export declare function commitLocalAct(store: string, identity: string, regions: readonly string[], prepare: () => Promise<LocalActBundle>, verify: LocalActVerification, storage?: PublicationStorage, signal?: AbortSignal): Promise<LocalActBundle & {
-    readonly kind: 'landed' | 'once';
-}>;

package/dist/host/ports/place-act.d.ts

@@ -1,49 +0,0 @@
-import { type TrustedClockContract, type PlaceReceipt, type RootContext } from '@lapxo/topos/core';
-import { type PlaceActPersistence } from '../place-act-transaction.ts';
-import { type PublicationStorage } from './publication.ts';
-export interface PlaceActBudget {
-    readonly acts: number;
-    readonly bytes: number;
-}
-export interface PlaceActHead {
-    readonly place: string;
-    readonly identity: string;
-    readonly epoch: string;
-}
-export interface PlaceActSnapshot {
-    readonly root: RootContext;
-    readonly heads: readonly PlaceActHead[];
-}
-/** Fixed instrument construction, never supplied by world JSON. Historical
- * authentication permits inspection only; current() is read under Root guards. */
-export interface PlaceActTrust {
-    readonly contract: TrustedClockContract;
-    readonly initialHeads: readonly PlaceActHead[];
-    readonly current: () => PlaceActSnapshot;
-    readonly historical: (encoded: string) => TrustedClockContract;
-}
-export interface PlaceActBundle {
-    readonly context: string;
-    readonly receipts: readonly PlaceReceipt[];
-    readonly originals: readonly (readonly string[])[];
-}
-/** Historical result reads never produce a current authorization permit. */
-export declare function placeActResult(store: string, id: string, trust: Pick<PlaceActTrust, 'historical'>, limits: PlaceActBudget): PlaceActBundle | undefined;
-/** Each receiver chain advances independently. Initial heads are explicit,
- * authenticated host inputs, not inferred zero or legacy global epochs. */
-export declare function placeActHeads(store: string, initial: readonly PlaceActHead[], trust: Pick<PlaceActTrust, 'historical' | 'contract'>, limits: PlaceActBudget): readonly PlaceActHead[];
-/** Context, exact original bytes and complete signed receipts have one visibility
- * point. Real Root guard exclusion spans final authority/head comparison and
- * publication; this does not activate a CLI profile or reinterpret local-act@1. */
-/** Native persistence adapter. The transaction below is also the CLI path. */
-export declare function nativePlaceActPersistence(store: string, storage?: PublicationStorage): PlaceActPersistence;
-export declare function commitPlaceAct(store: string, encoded: string, receipts: readonly PlaceReceipt[], trust: PlaceActTrust, limits: PlaceActBudget, storage?: PublicationStorage): Promise<PlaceActBundle & {
-    readonly kind: "landed" | "once";
-    readonly identity: string;
-}>;
-/** Enumerates only committed, historically authenticated carriers. Namespace
- * projection is a caller's separate pure operation, never current permission. */
-export declare function committedPlaceActResults(store: string, trust: Pick<PlaceActTrust, 'historical'>, limits: PlaceActBudget): readonly {
-    identity: string;
-    bundle: PlaceActBundle;
-}[];

package/dist/host/ports/publication.d.ts

@@ -1,10 +0,0 @@
-export interface PublicationStorage {
-    publish(staged: string, committed: string): void;
-}
-export declare const nativePublicationStorage: PublicationStorage;
-/** Publish prepared bytes as one directory. No identity, grammar or authority
- * is inferred here. Readers address the committed name, never staging files.
- * A failure after rename is not evidence of rollback: the caller must retain
- * the uncertainty and allow a verified read of the committed name.
- */
-export declare function publishBundle(committed: string, files: Readonly<Record<string, string>>, storage?: PublicationStorage): void;

package/dist/host/reference-export.d.ts

@@ -1,33 +0,0 @@
-import type { SigningPort } from '../engine/ports.ts';
-export { BoundRefusal as ReferenceExportRefusal } from './refusals.ts';
-/** Signs a public snapshot proof; never lands, refreshes evidence or changes the Root. */
-export declare function exportAuthenticatedReference(root: string, source: string, options?: {
-    readonly key?: string;
-    readonly keyFile?: string;
-    readonly signer?: string;
-    readonly hostSigner?: {
-        readonly name: string;
-        readonly sign: SigningPort;
-    };
-}): Promise<{
-    profile: string;
-    reference: string;
-    carrier: string;
-    context: {
-        snapshot: string;
-        profile: string;
-        semanticIdentity: string;
-        epoch: number;
-        proofScope: string;
-        policy: string;
-        formImplementation: string;
-        signers: readonly import("@lapxo/topos/wire").Signer[];
-        algorithms: readonly string[];
-        contracts: {
-            refusals: string;
-            standing: string;
-        };
-        maxBytes: number;
-        maxRecords: number;
-    };
-}>;

package/dist/host/reference-native.d.ts

@@ -1,30 +0,0 @@
-import { type ContentReadPort } from '../engine/ports.ts';
-export declare function authenticatedReferenceSelected(standing: readonly string[]): boolean;
-/** One context preparation shared by native export and native inspection. */
-export declare function prepareNativeReference(root: string): Promise<{
-    policy: string;
-    formImplementation: string;
-    records: readonly import("@lapxo/topos/wire").ObjectRecord[];
-    context: import("@lapxo/topos/wire").ObjectContext;
-    configuration: Readonly<Record<string, string>>[];
-}>;
-export declare function openAuthenticatedReference(root: string, fragment: string, options?: {
-    readonly signal?: AbortSignal;
-    readonly content?: {
-        readonly name: string;
-        readonly read: ContentReadPort;
-    };
-}): Promise<{
-    backend: string;
-    readings: readonly import("../engine/object.ts").ObjectReading[];
-    contracts?: {
-        refusals: string;
-        standing: string;
-    } | undefined;
-    reference: import("./reference-profile.ts").StandingReference;
-    records: readonly import("@lapxo/topos/wire").ObjectRecord[];
-    semanticIdentity: string;
-    authorityContextIdentity: string;
-    semanticStanding: string;
-    originalRecords: readonly string[];
-}>;

package/dist/host/reference-profile.d.ts

@@ -1,23 +0,0 @@
-/** reference-profile@1: platform URL parsing, no authority or transport effects. */
-export interface StandingReference {
-    readonly class: 'standing';
-    readonly algorithm: 'sha256';
-    readonly digest: string;
-    readonly blob: string;
-    readonly source: string;
-}
-interface InspectionPort {
-    readonly maxBytes: number;
-    readonly readSemanticStanding: (bytes: string) => readonly string[];
-    readonly semanticStandingBytes: (lines: readonly string[]) => string;
-    readonly digestBytes: (bytes: Uint8Array) => string;
-}
-export declare function encodeReference(reference: StandingReference): string;
-export declare function decodeReference(fragment: string): StandingReference;
-export declare function inspectReferenceBytes(reference: StandingReference, bytes: Uint8Array, { maxBytes, readSemanticStanding, semanticStandingBytes, digestBytes }: InspectionPort): {
-    reference: StandingReference;
-    lines: readonly string[];
-    standing: string;
-    authentication: string;
-};
-export {};

package/dist/host/refusals.d.ts

@@ -1,14 +0,0 @@
-export interface RefusalEntry {
-    readonly code: string;
-    readonly category: string;
-    readonly meaning: string;
-    readonly next: string;
-}
-/** Stable code assigned at the cause. Details are diagnostic, never parsed as policy. */
-export declare class BoundRefusal extends Error {
-    readonly code: string;
-    constructor(code: string, diagnostic: string);
-}
-/** Pure machine contract reader. A catalog is data, never an authority grant. */
-export declare function readRefusalCatalog(text: string): readonly RefusalEntry[];
-export declare function describeRefusal(error: BoundRefusal, catalog: readonly RefusalEntry[]): RefusalEntry;

package/dist/host/root-clock-source.d.ts

@@ -1,86 +0,0 @@
-import { type PlaceReceipt, type ClockBudget } from '@lapxo/topos/core';
-import type { PlaceActBudget } from './ports/place-act.ts';
-export interface RootClockSourceSelection {
-    readonly selector: string;
-    readonly profileSelector: string;
-    readonly bootstrapCheckpoint: {
-        scope: string;
-        measure: string;
-    };
-    readonly resources: {
-        bytes: number;
-        lines: number;
-        places: number;
-        acts: number;
-    };
-    readonly inherited: {
-        clock: ClockBudget;
-        storage: PlaceActBudget;
-    };
-}
-export declare function rootClockSource(root: string, selected: RootClockSourceSelection): {
-    observation: Readonly<{
-        history: readonly string[];
-        anchor: import("@lapxo/topos/wire").Signer;
-        algorithms: readonly string[];
-    }>;
-    resources: Readonly<{
-        bytes: number;
-        lines: number;
-        places: number;
-        acts: number;
-    }>;
-    authority: (encoded: string) => {
-        anchor: import("@lapxo/topos/wire").Signer;
-        history: readonly string[];
-        checkpoint: string;
-    };
-    selection: import("./place-clock-selection.ts").HostClockSelection;
-    trust: import("./ports/place-act.ts").PlaceActTrust;
-};
-/** Source mapping is an explicit Root declaration; absence never means a zero
- * clock or an inferred cursor. Existing legacy callers do not request it. */
-export declare function rootClockSelectionOf(live: readonly string[], anchor: import('@lapxo/topos/wire').Signer): RootClockSourceSelection;
-export declare function declaredRootClockSource(root: string): {
-    observation: Readonly<{
-        history: readonly string[];
-        anchor: import("@lapxo/topos/wire").Signer;
-        algorithms: readonly string[];
-    }>;
-    resources: Readonly<{
-        bytes: number;
-        lines: number;
-        places: number;
-        acts: number;
-    }>;
-    authority: (encoded: string) => {
-        anchor: import("@lapxo/topos/wire").Signer;
-        history: readonly string[];
-        checkpoint: string;
-    };
-    selection: import("./place-clock-selection.ts").HostClockSelection;
-    trust: import("./ports/place-act.ts").PlaceActTrust;
-};
-export declare function hasRootClockSource(root: string): boolean;
-export interface PortablePlaceContext {
-    readonly identity: string;
-    readonly context: string;
-    readonly receipts: readonly PlaceReceipt[];
-    readonly authority: {
-        anchor: import('@lapxo/topos/wire').Signer;
-        history: readonly string[];
-        checkpoint: string;
-    };
-}
-/** Historical inspection ONLY. The expected acting Root anchor and resource
- * selection come from the consumer's selected place, never from this packet.
- * This function returns data and cannot construct a current command permit. */
-export declare function inspectPortablePlaceContexts(encoded: string, expectedAnchor: import('@lapxo/topos/wire').Signer, selected: RootClockSourceSelection): {
-    identity: string;
-    context: import("@lapxo/topos/core").PlaceAct;
-}[];
-/** Prospective configuration is checked as authenticated Root history, never
- * against a prose birth condition. Initial heads are explicit typed selections;
- * stored committed chains cannot disappear when a selection is activated or
- * replaced. Preview reads only; the real admission repeats under its Root lock. */
-export declare function assertProspectiveRootClockSelection(root: string, signed: readonly string[]): void;

package/licenses/wasm/jitl-quickjs-ffi-types.txt

@@ -1,21 +0,0 @@
-The MIT License
-
-quickjs-emscripten copyright (c) 2019-2024 Jake Teton-Landis
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.