@lapxo/bound 0.2.4 → 0.2.5

package/.github/workflows/release.yml

@@ -1,67 +0,0 @@
-name: release
-on:
-  workflow_run:
-    workflows: [tag]
-    types: [completed]
-  workflow_dispatch:
-jobs:
-  stage:
-    if: github.event_name == 'workflow_dispatch' || (github.event.workflow_run.conclusion == 'success' && github.event.workflow_run.head_branch == 'main')
-    concurrency: release-delivery
-    environment: release
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-      id-token: write
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: ${{ github.event.workflow_run.head_sha || github.sha }}
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 24
-      - run: npm ci --ignore-scripts
-      - run: npm run build
-      - run: npm install --global npm@'12.1.0' --ignore-scripts
-      - name: Prepare release
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          set -euo pipefail
-          TAG="v$(node -p "require('./package.json').version")"
-          printf 'TAG=%s\n' "$TAG" >> "$GITHUB_ENV"
-          git fetch origin "refs/tags/$TAG:refs/tags/$TAG"
-          gh api --paginate "repos/$GITHUB_REPOSITORY/releases" --jq '.[].tag_name' > "$RUNNER_TEMP/release-tags"
-          if grep -Fxq "$TAG" "$RUNNER_TEMP/release-tags"; then
-            printf 'RELEASE %s · exists\n' "$TAG"
-          else
-            gh release create "$TAG" --verify-tag --draft --title "$TAG" --generate-notes
-            printf 'RELEASE %s · draft created · awaiting signed assets\n' "$TAG"
-          fi
-      - name: Read owner approval
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          set -euo pipefail
-          mkdir .release
-          gh release download "$TAG" --pattern approval-signed --dir .release
-          node dist/cli/verb.js fold --as release .release/approval-signed > .release/verdict
-          cat .release/verdict
-      - name: Stage the approved release archive
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          set -euo pipefail
-          read -r status digest archive source extra < .release/verdict
-          test "$status" = READY
-          test -z "$extra"
-          gh release download "$TAG" --pattern "$archive" --dir .release
-          printf '%s  %s\n' "${digest#sha256:}" ".release/$archive" | sha256sum -c -
-          expected="$(node -p "require('./package.json').name+'@'+require('./package.json').version")"
-          actual="$(tar -xOf ".release/$archive" package/package.json | node -p "const p=JSON.parse(require('fs').readFileSync(0,'utf8'));p.name+'@'+p.version")"
-          test "$actual" = "$expected"
-          printf 'SOURCE release/%s/%s · %s · declared %s\n' "$TAG" "$archive" "$digest" "$source"
-          gh release edit "$TAG" --draft=false
-          printf 'RELEASE %s · published · %s\n' "$TAG" "$digest"
-          npm stage publish ".release/$archive" --access public --ignore-scripts
-          printf 'STAGED %s · %s · owner approval pending\n' "$actual" "$digest"

package/.github/workflows/test.yml

@@ -1,35 +0,0 @@
-name: test
-on:
-  push:
-    branches: [main]
-  pull_request:
-permissions:
-  contents: read
-jobs:
-  test:
-    strategy:
-      fail-fast: false
-      matrix:
-        node: [22, 24]
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          persist-credentials: false
-      - uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node }}
-      - run: npm ci
-      - run: npm run build
-      - name: Run tests
-        run: |
-          set -euo pipefail
-          npm test 2>&1 | tee "$RUNNER_TEMP/bound-tests.log"
-      - run: npm pack --pack-destination "$RUNNER_TEMP" --silent
-      - name: Preserve test logs
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: bound-node-${{ matrix.node }}
-          path: ${{ runner.temp }}/bound-tests.log
-          if-no-files-found: ignore

package/dist/engine/object.d.ts

@@ -1,17 +0,0 @@
-import type { Mark, Cell } from '@lapxo/obligations/views/field';
-import type { ObjectRecord, ObjectContext } from '@lapxo/topos/wire';
-/** Projection dispatches admitted acts into Obligatory; it defines no meet or propagation. */
-export interface ObjectReading {
-    cell: string;
-    state: string;
-    parts: Cell<unknown>;
-    rest: readonly string[];
-    ownMarks: readonly (string | undefined)[];
-    ownClaims: readonly {
-        id: string | undefined;
-        origin: string;
-    }[];
-    marks: readonly Mark<unknown>[];
-    claims: readonly unknown[];
-}
-export declare function objectFold(records: readonly ObjectRecord[], context: ObjectContext): readonly ObjectReading[];

package/dist/engine/ports.d.ts

@@ -1,37 +0,0 @@
-export interface PortLimits {
-    readonly timeoutMs: number;
-    readonly maxBytes: number;
-}
-export interface SigningLot {
-    readonly bytes: readonly string[];
-    readonly keyId: string;
-    readonly algorithm: string;
-}
-export interface SignatureRecord {
-    readonly keyId: string;
-    readonly signature: string;
-}
-export type SigningPort = (lot: SigningLot, signal: AbortSignal) => Promise<readonly SignatureRecord[]>;
-export type ContentReadPort = (source: string, digest: string, signal: AbortSignal) => Promise<Uint8Array>;
-/** Atomic byte retention supplied by the host. This is neither admission nor a current-answer cache. */
-export type PersistencePort = (digest: string, bytes: Uint8Array, signal: AbortSignal) => Promise<void>;
-export type DigestPort = (bytes: Uint8Array) => string | Promise<string>;
-export declare function readContent(source: string, digest: string, ports: {
-    readonly read: ContentReadPort;
-    readonly digestBytes: DigestPort;
-}, limits: PortLimits, signal?: AbortSignal): Promise<Uint8Array>;
-/** Verify before invoking retention; no operation automatically writes the projected result. */
-export declare function retainContent(digest: string, bytes: Uint8Array, ports: {
-    readonly retain: PersistencePort;
-    readonly digestBytes: DigestPort;
-}, limits: PortLimits, signal?: AbortSignal): Promise<{
-    readonly digest: string;
-    readonly bytes: number;
-}>;
-/** Acquire canonical line signatures only. The line protocol is not widened
- * for contextual receipt frames. Both operations share bounds and response checks. */
-export declare function invokeSigningPort(lot: SigningLot, sign: SigningPort, limits: PortLimits, signal?: AbortSignal): Promise<readonly SignatureRecord[]>;
-/** Host-prepared signature frames. This acquires no authority: the contextual
- * transaction validates the frame's domain/receiver and verifies every signature.
- * A carrier cannot select this operation or supply a signature verifier. */
-export declare function invokeFrameSigningPort(lot: SigningLot, sign: SigningPort, limits: PortLimits, signal?: AbortSignal): Promise<readonly SignatureRecord[]>;

package/dist/fold/claims.d.ts

@@ -1,29 +0,0 @@
-import { parse } from '@lapxo/topos/wire';
-export { CAPSULE, EXTENSION, LOCK, RECEIPTS } from '@lapxo/topos/wire';
-/** Pure syntax is retained by the exact record bytes, never by a path, epoch or
- * claimed digest. This does not retain admission, coverage or current grants. */
-export declare function parsedLine(line: string): ReturnType<typeof parse>;
-export declare const fieldOf: (line: string, name: string) => string;
-export declare const fieldsOf: (line: string) => Record<string, string>;
-export declare function selfName(): string;
-export declare function isWire(line: string): boolean;
-export declare const wireLinesOf: (text: string | undefined) => readonly string[];
-export declare const isConfig: (line: string) => boolean;
-export declare const sayingOf: (line: string) => string;
-/** One key per claim: scope, role and measure; what a line says, its envelope set aside, is one however often it landed. */
-export declare function claimKey(line: string): string;
-export interface Fork {
-    readonly key: string;
-    readonly lines: readonly string[];
-    readonly state?: string;
-}
-export declare function foldClaims(lines: readonly string[], receipts?: readonly {
-    readonly scope: string;
-    readonly moved: readonly string[];
-}[], _placed?: boolean): {
-    readonly standing: readonly string[];
-    readonly superseded: readonly string[];
-    readonly retracted: readonly string[];
-    readonly forks: readonly Fork[];
-    readonly vacuous: readonly string[];
-};

package/dist/host/call-context.d.ts

@@ -1,20 +0,0 @@
-/** Native operational selection from the receiver, never the offered content. */
-export interface HostInstrumentRuntime {
-    readonly root: string;
-    readonly entry: string;
-    readonly directory: string;
-    readonly extension: '.ts' | '.js';
-    readonly lock: readonly string[];
-}
-interface HostCall {
-    readonly instrumentName: string;
-    readonly runtime?: HostInstrumentRuntime;
-    readonly output?: (stream: 'out' | 'error', text: string) => void;
-}
-export declare const hostInstrumentName: () => string | undefined;
-export declare const hostInstrumentRuntime: () => HostInstrumentRuntime | undefined;
-export declare const withHostInstrument: <T>(instrumentName: string, run: () => T) => T;
-export declare const withHostCall: <T>(call: HostCall, run: () => T) => T;
-/** No stream monkey-patching: diagnostics follow only this asynchronous call. */
-export declare function hostOutput(stream: 'out' | 'error', text: string): void;
-export {};

package/dist/host/commit-result.d.ts

@@ -1,6 +0,0 @@
-import { BoundRefusal } from './refusals.ts';
-/** Visibility may precede a failed publication response; never asserts rollback. */
-export declare class ActCommitUnknown extends BoundRefusal {
-    readonly identity: string;
-    constructor(identity: string, cause: unknown);
-}

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

@@ -1,82 +0,0 @@
-import { type ReadingIdentityContext } from '@lapxo/topos/contract';
-import { type ContentReadPort, type SigningPort, type PortLimits } from '../engine/ports.ts';
-import { type PlaceActPersistence } from './place-act-transaction.ts';
-import type { PlaceActTrust, PlaceActBudget } from './ports/place-act.ts';
-export interface PlaceActHostContext {
-    readonly place: string;
-    readonly source: string;
-    readonly identity: string;
-    readonly rootSnapshot: string;
-    readonly reading: ReadingIdentityContext;
-    readonly algorithm: string;
-    readonly contentLimits: PortLimits;
-    readonly signingLimits: PortLimits;
-    readonly storageLimits: PlaceActBudget;
-    readonly signal?: AbortSignal;
-}
-/** These are receiver-selected host ports, not carrier fields or an offered
- * verifier. Trust must be constructed from the authenticated receiver snapshot. */
-export interface PlaceActHostPorts {
-    readonly instrumentName: string;
-    readonly read: ContentReadPort;
-    readonly sign: SigningPort;
-    readonly trust: () => PlaceActTrust;
-    readonly persistence: PlaceActPersistence;
-    readonly limits: {
-        readonly storage: PlaceActBudget;
-        readonly signing: PortLimits;
-        readonly content: PortLimits;
-    };
-}
-/** Signs receiver receipts through the bounded existing signer protocol. Exact
- * original declarations/proofs remain unchanged. Replay is historical recovery,
- * never a new permission. A refusal after visibility is not a rollback claim. */
-export declare function landPlaceActInProcess(context: PlaceActHostContext, ports: PlaceActHostPorts): Promise<{
-    kind: "fact";
-    value: {
-        place: string;
-        act: import("./ports/place-act.ts").PlaceActBundle & {
-            readonly kind: "landed" | "once";
-            readonly identity: string;
-        };
-        reading: string;
-        result: string;
-        commitment: string;
-    };
-    identity?: undefined;
-    code?: undefined;
-    diagnostic?: undefined;
-} | {
-    kind: "uncertain";
-    identity: string;
-    code: string;
-    diagnostic: string;
-    value?: undefined;
-} | {
-    kind: "refuse";
-    code: string;
-    diagnostic: string;
-    value?: undefined;
-    identity?: undefined;
-}>;
-/** Historical recovery after a lost response. No signer, current authorization
- * or publication callback is invoked and the result grants no new act. */
-export declare function recoverPlaceActInProcess(context: Pick<PlaceActHostContext, 'place' | 'identity' | 'reading' | 'storageLimits' | 'signal'>, ports: Pick<PlaceActHostPorts, 'instrumentName' | 'trust' | 'persistence' | 'limits'>): {
-    kind: "fact";
-    value: {
-        place: string;
-        identity: string;
-        act: import("./ports/place-act.ts").PlaceActBundle;
-        historical: true;
-        reading: string;
-        result: string;
-        commitment: string;
-    };
-    code?: undefined;
-    diagnostic?: undefined;
-} | {
-    kind: "refuse";
-    code: string;
-    diagnostic: string;
-    value?: undefined;
-};

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