@opengeni/artifact-tool 0.2.2

package/dist/runtime-cli.d.ts

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+import { type ArtifactKernelRuntime, type ArtifactRuntimeTarget } from "./runtime.js";
+type RuntimeEnvironment = Readonly<Record<string, string | undefined>>;
+export type VerifiedArtifactRuntimeLocation = Readonly<{
+    schemaVersion: 1;
+    target: ArtifactRuntimeTarget;
+    manifestPath: string;
+    releaseManifestPath: string;
+    artifactTool: Readonly<{
+        packageName: "@opengeni/artifact-tool";
+        packageVersion: string;
+        integrity: `sha512-${string}`;
+    }>;
+    artifactToolArchive?: string;
+    skillFacadeEntrypoint: string;
+    skillFacadeSupportFiles?: readonly string[];
+    kernel: Readonly<{
+        packageName: string;
+        packageVersion: string;
+        entrypoint: string;
+        asset: string;
+        supportFiles: readonly string[];
+        buildIdentity: string;
+    }>;
+}>;
+export type LocateArtifactRuntimeOptions = Readonly<{
+    environment?: RuntimeEnvironment;
+    /** Test/build override. The executable always derives the current host target. */
+    expectedTarget?: ArtifactRuntimeTarget;
+}>;
+export type DoctorArtifactRuntimeOptions = LocateArtifactRuntimeOptions & Readonly<{
+    importer?: (specifier: string) => unknown | Promise<unknown>;
+    probe?: (module: Record<string, unknown>) => void | Promise<void>;
+}>;
+export type VerifiedArtifactKernelRuntime = Readonly<{
+    location: VerifiedArtifactRuntimeLocation;
+    runtime: ArtifactKernelRuntime;
+}>;
+/**
+ * Verifies the complete local release/install chain without evaluating any
+ * package code. All reads are local, bounded, streamed where large, and pinned
+ * to exact byte counts plus SHA-256 digests.
+ */
+export declare function locateVerifiedArtifactRuntime(options?: LocateArtifactRuntimeOptions): Promise<VerifiedArtifactRuntimeLocation>;
+/** Verify first, then evaluate the one pinned bootstrap and probe its facade. */
+export declare function doctorVerifiedArtifactRuntime(options?: DoctorArtifactRuntimeOptions): Promise<VerifiedArtifactRuntimeLocation>;
+/**
+ * Loads only the manifest-pinned native kernel package after verifying every
+ * selected runtime byte. A second complete verification after evaluation
+ * closes ordinary replacement races; production additionally mounts this
+ * installation read-only inside the materializer sandbox.
+ */
+export declare function loadVerifiedArtifactKernelRuntime(options?: LocateArtifactRuntimeOptions): Promise<VerifiedArtifactKernelRuntime>;
+/** Deterministic bytes used by release tooling and verified by the locator. */
+export declare function canonicalArtifactRuntimeReleaseManifestBytes(value: unknown): Uint8Array;
+/** Deterministic installation bytes; the strict locator rejects other encodings. */
+export declare function canonicalArtifactRuntimeInstallationManifestBytes(value: unknown): Uint8Array;
+export declare function resolveCurrentArtifactRuntimeTarget(): ArtifactRuntimeTarget;
+export declare function runArtifactRuntimeCli(args: readonly string[], environment?: RuntimeEnvironment): Promise<string>;
+export type LinuxLibcRuntimeEvidence = Readonly<{
+    arch: string;
+    versions: Readonly<Record<string, string | undefined>>;
+    report?: Readonly<{
+        header?: Readonly<{
+            glibcVersionRuntime?: unknown;
+            release?: Readonly<{
+                sourceUrl?: unknown;
+            }>;
+        }>;
+        sharedObjects?: unknown;
+    }>;
+}>;
+/** Resolves only mutually consistent evidence about the running Linux binary. */
+export declare function resolveLinuxLibcFromRuntimeEvidence(evidence: LinuxLibcRuntimeEvidence): "gnu" | "musl";
+export declare function probeVerifiedArtifactSkillFacade(module: Record<string, unknown>, location: Pick<VerifiedArtifactRuntimeLocation, "target" | "kernel">): void;
+export {};

package/dist/runtime-cli.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import {
+  canonicalArtifactRuntimeInstallationManifestBytes,
+  canonicalArtifactRuntimeReleaseManifestBytes,
+  doctorVerifiedArtifactRuntime,
+  loadVerifiedArtifactKernelRuntime,
+  locateVerifiedArtifactRuntime,
+  probeVerifiedArtifactSkillFacade,
+  resolveCurrentArtifactRuntimeTarget,
+  resolveLinuxLibcFromRuntimeEvidence,
+  runArtifactRuntimeCli
+} from "./chunk-ZCJYRJGB.js";
+import "./chunk-N2IHNWBS.js";
+import "./chunk-VUNV25KB.js";
+export {
+  canonicalArtifactRuntimeInstallationManifestBytes,
+  canonicalArtifactRuntimeReleaseManifestBytes,
+  doctorVerifiedArtifactRuntime,
+  loadVerifiedArtifactKernelRuntime,
+  locateVerifiedArtifactRuntime,
+  probeVerifiedArtifactSkillFacade,
+  resolveCurrentArtifactRuntimeTarget,
+  resolveLinuxLibcFromRuntimeEvidence,
+  runArtifactRuntimeCli
+};
+//# sourceMappingURL=runtime-cli.js.map

package/dist/runtime-cli.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/runtime-development.d.ts

@@ -0,0 +1,73 @@
+import { type ArtifactKernelPackageManifest, type ArtifactKernelRuntime, type NativeArtifactRuntimeTarget } from "./runtime.js";
+import { type VerifiedArtifactRuntimeLocation } from "./runtime-cli.js";
+export declare const DEVELOPMENT_ARTIFACT_RUNTIME_ENVIRONMENT: {
+    readonly manifest: "OPENGENI_ARTIFACT_DEVELOPMENT_RUNTIME_MANIFEST";
+};
+type RuntimeEnvironment = Readonly<Record<string, string | undefined>>;
+type FileDescriptor = Readonly<{
+    path: string;
+    bytes: number;
+    sha256: `sha256:${string}`;
+}>;
+export type DevelopmentArtifactRuntimeManifest = Readonly<{
+    schemaVersion: 1;
+    mode: "development-current-host";
+    target: NativeArtifactRuntimeTarget;
+    sourceFingerprint: `sha256:${string}`;
+    artifactTool: Readonly<{
+        packageName: "@opengeni/artifact-tool";
+        packageVersion: string;
+    }>;
+    artifactToolIdentity: FileDescriptor;
+    receipt: FileDescriptor;
+    skillFacadeEntrypoint: FileDescriptor;
+    materializerExecutable: FileDescriptor;
+    kernelPackageRoot: string;
+    kernel: ArtifactKernelPackageManifest;
+}>;
+export type VerifiedDevelopmentArtifactRuntimeLocation = Readonly<{
+    schemaVersion: 1;
+    mode: "development-current-host";
+    target: NativeArtifactRuntimeTarget;
+    manifestPath: string;
+    receiptPath: string;
+    artifactTool: DevelopmentArtifactRuntimeManifest["artifactTool"];
+    skillFacadeEntrypoint: string;
+    materializerExecutable: string;
+    kernel: Readonly<{
+        packageName: string;
+        packageVersion: string;
+        entrypoint: string;
+        asset: string;
+        supportFiles: readonly string[];
+        buildIdentity: string;
+    }>;
+}>;
+export type ConfiguredArtifactRuntimeLocation = VerifiedArtifactRuntimeLocation | VerifiedDevelopmentArtifactRuntimeLocation;
+export type VerifiedConfiguredArtifactKernelRuntime = Readonly<{
+    location: ConfiguredArtifactRuntimeLocation;
+    runtime: ArtifactKernelRuntime;
+}>;
+/** True when any production/development runtime authority was explicitly supplied. */
+export declare function isArtifactRuntimeConfigured(environment?: RuntimeEnvironment): boolean;
+export declare function validateDevelopmentArtifactRuntimeManifest(value: unknown, expectedTarget?: NativeArtifactRuntimeTarget): DevelopmentArtifactRuntimeManifest;
+export declare function canonicalDevelopmentArtifactRuntimeManifestBytes(value: unknown): Uint8Array;
+export declare function canonicalDevelopmentArtifactToolIdentityBytes(artifactTool: DevelopmentArtifactRuntimeManifest["artifactTool"]): Uint8Array;
+export declare function locateVerifiedDevelopmentArtifactRuntime(options?: {
+    environment?: RuntimeEnvironment;
+    expectedTarget?: NativeArtifactRuntimeTarget;
+}): Promise<VerifiedDevelopmentArtifactRuntimeLocation>;
+export declare function doctorVerifiedDevelopmentArtifactRuntime(options?: {
+    environment?: RuntimeEnvironment;
+    expectedTarget?: NativeArtifactRuntimeTarget;
+    importer?: (specifier: string) => unknown | Promise<unknown>;
+    probe?: (module: Record<string, unknown>) => void | Promise<void>;
+}): Promise<VerifiedDevelopmentArtifactRuntimeLocation>;
+export declare function loadVerifiedDevelopmentArtifactKernelRuntime(options?: {
+    environment?: RuntimeEnvironment;
+    expectedTarget?: NativeArtifactRuntimeTarget;
+}): Promise<VerifiedConfiguredArtifactKernelRuntime>;
+export declare function doctorConfiguredArtifactRuntime(environment?: RuntimeEnvironment): Promise<ConfiguredArtifactRuntimeLocation>;
+export declare function loadConfiguredArtifactKernelRuntime(environment?: RuntimeEnvironment): Promise<VerifiedConfiguredArtifactKernelRuntime>;
+export declare function runConfiguredArtifactRuntimeCli(args: readonly string[], environment?: RuntimeEnvironment): Promise<string>;
+export {};

package/dist/runtime-development.js

@@ -0,0 +1,30 @@
+import {
+  DEVELOPMENT_ARTIFACT_RUNTIME_ENVIRONMENT,
+  canonicalDevelopmentArtifactRuntimeManifestBytes,
+  canonicalDevelopmentArtifactToolIdentityBytes,
+  doctorConfiguredArtifactRuntime,
+  doctorVerifiedDevelopmentArtifactRuntime,
+  isArtifactRuntimeConfigured,
+  loadConfiguredArtifactKernelRuntime,
+  loadVerifiedDevelopmentArtifactKernelRuntime,
+  locateVerifiedDevelopmentArtifactRuntime,
+  runConfiguredArtifactRuntimeCli,
+  validateDevelopmentArtifactRuntimeManifest
+} from "./chunk-U5G2BKM2.js";
+import "./chunk-ZCJYRJGB.js";
+import "./chunk-N2IHNWBS.js";
+import "./chunk-VUNV25KB.js";
+export {
+  DEVELOPMENT_ARTIFACT_RUNTIME_ENVIRONMENT,
+  canonicalDevelopmentArtifactRuntimeManifestBytes,
+  canonicalDevelopmentArtifactToolIdentityBytes,
+  doctorConfiguredArtifactRuntime,
+  doctorVerifiedDevelopmentArtifactRuntime,
+  isArtifactRuntimeConfigured,
+  loadConfiguredArtifactKernelRuntime,
+  loadVerifiedDevelopmentArtifactKernelRuntime,
+  locateVerifiedDevelopmentArtifactRuntime,
+  runConfiguredArtifactRuntimeCli,
+  validateDevelopmentArtifactRuntimeManifest
+};
+//# sourceMappingURL=runtime-development.js.map

package/dist/runtime-development.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/runtime-receipt.d.ts

@@ -0,0 +1,19 @@
+import { type ArtifactRuntimeTarget } from "./runtime.js";
+export type ArtifactKernelBuildReceipt = Readonly<{
+    schemaVersion: 1;
+    producer: "opengeni-artifact-kernel-smoke-v1";
+    target: ArtifactRuntimeTarget;
+    kind: "native" | "wasm";
+    buildIdentity: string;
+    capabilities: Readonly<{
+        bytes: number;
+        sha256: `sha256:${string}`;
+    }>;
+    runtimeFiles: readonly Readonly<{
+        path: string;
+        bytes: number;
+        sha256: `sha256:${string}`;
+    }>[];
+}>;
+export declare function validateArtifactKernelBuildReceipt(value: unknown, expectedTarget?: ArtifactRuntimeTarget): ArtifactKernelBuildReceipt;
+export declare function canonicalArtifactKernelBuildReceiptBytes(value: unknown): Uint8Array;

package/dist/runtime.d.ts

@@ -0,0 +1,355 @@
+/**
+ * Exact artifact-kernel distribution and runtime boundary.
+ *
+ * This module never downloads a binary, installs a package, guesses `latest`,
+ * or falls back to the TypeScript reference implementation. A host supplies
+ * one exact, locally installed target package and this boundary verifies its
+ * manifest and byte ABI before exposing a kernel session.
+ */
+export declare const ARTIFACT_RUNTIME_ENVIRONMENT: {
+    readonly manifest: "OPENGENI_ARTIFACT_RUNTIME_MANIFEST";
+    readonly toolEntrypoint: "OPENGENI_ARTIFACT_TOOL_ENTRY";
+};
+export declare const ARTIFACT_RUNTIME_TARGETS: readonly ["darwin-x64", "darwin-arm64", "linux-x64-gnu", "linux-arm64-gnu", "linux-x64-musl", "linux-arm64-musl", "win32-x64-msvc", "wasm-web"];
+export type ArtifactRuntimeTarget = (typeof ARTIFACT_RUNTIME_TARGETS)[number];
+export type NativeArtifactRuntimeTarget = Exclude<ArtifactRuntimeTarget, "wasm-web">;
+export type ArtifactRuntimeKind = "native" | "wasm";
+export type ArtifactRuntimeLibc = "gnu" | "musl";
+export type ArtifactRuntimeTargetDescriptor = {
+    readonly target: ArtifactRuntimeTarget;
+    readonly kind: ArtifactRuntimeKind;
+    readonly packageName: ArtifactKernelPackageName;
+    readonly platform: "darwin" | "linux" | "win32" | "browser";
+    readonly arch: "x64" | "arm64" | "wasm32";
+    readonly libc?: ArtifactRuntimeLibc;
+};
+export declare const ARTIFACT_RUNTIME_MATRIX: readonly [ArtifactRuntimeTargetDescriptor & {
+    readonly target: "darwin-x64";
+    readonly kind: "native";
+    readonly platform: "darwin";
+    readonly arch: "x64";
+}, ArtifactRuntimeTargetDescriptor & {
+    readonly target: "darwin-arm64";
+    readonly kind: "native";
+    readonly platform: "darwin";
+    readonly arch: "arm64";
+}, ArtifactRuntimeTargetDescriptor & {
+    readonly target: "linux-x64-gnu";
+    readonly kind: "native";
+    readonly platform: "linux";
+    readonly arch: "x64";
+}, ArtifactRuntimeTargetDescriptor & {
+    readonly target: "linux-arm64-gnu";
+    readonly kind: "native";
+    readonly platform: "linux";
+    readonly arch: "arm64";
+}, ArtifactRuntimeTargetDescriptor & {
+    readonly target: "linux-x64-musl";
+    readonly kind: "native";
+    readonly platform: "linux";
+    readonly arch: "x64";
+}, ArtifactRuntimeTargetDescriptor & {
+    readonly target: "linux-arm64-musl";
+    readonly kind: "native";
+    readonly platform: "linux";
+    readonly arch: "arm64";
+}, ArtifactRuntimeTargetDescriptor & {
+    readonly target: "win32-x64-msvc";
+    readonly kind: "native";
+    readonly platform: "win32";
+    readonly arch: "x64";
+}, ArtifactRuntimeTargetDescriptor & {
+    readonly target: "wasm-web";
+    readonly kind: "wasm";
+    readonly platform: "browser";
+    readonly arch: "wasm32";
+}];
+export type ArtifactKernelPackageName = `@opengeni/artifact-kernel-${ArtifactRuntimeTarget}`;
+export type ArtifactKernelPackageManifest = {
+    readonly schemaVersion: 1;
+    readonly target: ArtifactRuntimeTarget;
+    readonly kind: ArtifactRuntimeKind;
+    readonly packageName: ArtifactKernelPackageName;
+    readonly packageVersion: string;
+    readonly artifactToolVersion: string;
+    readonly buildIdentity: string;
+    readonly entrypoint: {
+        readonly path: string;
+        readonly bytes: number;
+        readonly sha256: `sha256:${string}`;
+    };
+    readonly asset: {
+        readonly path: string;
+        readonly bytes: number;
+        readonly sha256: `sha256:${string}`;
+    };
+    /** Additional executable runtime files (for example wasm-bindgen glue). */
+    readonly supportFiles: readonly {
+        readonly path: string;
+        readonly bytes: number;
+        readonly sha256: `sha256:${string}`;
+    }[];
+};
+/** Self-contained identity embedded in executable package code (no self-hash). */
+export type ArtifactKernelPackageIdentity = Pick<ArtifactKernelPackageManifest, "schemaVersion" | "target" | "kind" | "packageName" | "packageVersion" | "artifactToolVersion" | "buildIdentity">;
+export type ArtifactRuntimeInstallationManifest = {
+    readonly schemaVersion: 1;
+    readonly target: ArtifactRuntimeTarget;
+    readonly releaseManifest: {
+        readonly path: string;
+        readonly bytes: number;
+        readonly sha256: `sha256:${string}`;
+    };
+    readonly artifactTool: {
+        readonly packageName: "@opengeni/artifact-tool";
+        readonly packageVersion: string;
+        readonly integrity: `sha512-${string}`;
+    };
+    /** Exact packed package whose SHA-512 is `artifactTool.integrity`. */
+    readonly artifactToolArchive?: {
+        readonly path: string;
+        readonly bytes: number;
+        readonly sha256: `sha256:${string}`;
+    };
+    readonly skillFacadeEntrypoint: {
+        readonly path: string;
+        readonly bytes: number;
+        readonly sha256: `sha256:${string}`;
+    };
+    /**
+     * Optional, installation-local files dynamically loaded by the facade.
+     *
+     * A plain server installation can omit this when its package manager owns
+     * those dependencies. A portable sandbox installation lists every vendored
+     * runtime file here so locator/doctor verifies the complete executable
+     * closure before evaluating the facade.
+     */
+    readonly skillFacadeSupportFiles?: readonly {
+        readonly path: string;
+        readonly bytes: number;
+        readonly sha256: `sha256:${string}`;
+    }[];
+    readonly kernelPackageRoot: string;
+    readonly kernel: ArtifactKernelPackageManifest;
+};
+export type ArtifactRuntimeReleaseManifest = {
+    readonly schemaVersion: 1;
+    readonly artifactTool: {
+        readonly packageName: "@opengeni/artifact-tool";
+        readonly packageVersion: string;
+        readonly integrity: `sha512-${string}`;
+    };
+    readonly targets: readonly ArtifactKernelPackageManifest[];
+};
+export type ArtifactRuntimeDependencies = {
+    readonly target: ArtifactRuntimeTargetDescriptor;
+    readonly manifestUrl: URL;
+    readonly releaseManifestUrl: URL;
+    readonly artifactToolArchiveUrl?: URL;
+    readonly skillFacadeEntrypoint: URL;
+    readonly skillFacadeSupportFiles: readonly URL[];
+    readonly kernelEntrypoint: URL;
+    readonly kernelAsset: URL;
+    readonly kernelSupportFiles: readonly URL[];
+    readonly manifest: ArtifactRuntimeInstallationManifest;
+};
+export type ArtifactRuntimeKernelDependencies = Pick<ArtifactRuntimeDependencies, "target" | "kernelEntrypoint"> & Readonly<{
+    manifest: Pick<ArtifactRuntimeInstallationManifest, "kernel">;
+}>;
+export type ArtifactKernelCapabilities = {
+    readonly abiVersion: 1;
+    readonly buildIdentityFormat: "utf8";
+    readonly commandSchemaVersion: 1;
+    readonly spreadsheetCommandVersion: 1;
+    readonly kernelSnapshotVersion: 1;
+    readonly receiptSchemaVersion: 1;
+    readonly collaborationSnapshotVersion: 1;
+    readonly editableArtifactIntentVersion: 1;
+    readonly committedTransactionVersion: 1;
+    readonly queryVersion: 1;
+    readonly queryResponseVersion: 1;
+    readonly collaboration: true;
+    readonly document: true;
+    readonly documentCommandVersion: 1;
+    readonly documentQueryResponseVersion: 1;
+    readonly documentQueryVersion: 1;
+    readonly documentReceiptVersion: 1;
+    readonly documentSnapshotVersion: 1;
+    readonly documentStatefulSessions: true;
+    readonly presentation: true;
+    readonly presentationCommandVersion: 1;
+    readonly presentationQueryResponseVersion: 1;
+    readonly presentationQueryVersion: 1;
+    readonly presentationSnapshotVersion: 1;
+    readonly presentationStatefulSessions: true;
+    readonly textLayout: true;
+    readonly textLayoutFontBundleVersion: 1;
+    readonly textLayoutRequestVersion: 1;
+    readonly textLayoutResponseVersion: 1;
+    readonly textLayoutStatefulSessions: true;
+    readonly retainedRenderPatchVersion: 1;
+    readonly retainedRenderTileVersion: 1;
+    readonly workbookMetadataQueries: true;
+    readonly canonicalStateHash: "sha256:canonical-snapshot";
+    readonly maxCellsPerBatch: number;
+    readonly maxCommandBytes: number;
+    readonly maxCommands: number;
+    readonly maxCommittedTransactionBytes: number;
+    readonly maxDocumentCommandBytes: number;
+    readonly maxDocumentCommands: number;
+    readonly maxDocumentQueryBytes: number;
+    readonly maxDocumentQueryResponseBytes: number;
+    readonly maxDocumentSnapshotBytes: number;
+    readonly maxIntentBytes: number;
+    readonly maxMetadataScannedCells: number;
+    readonly maxMetadataSheets: number;
+    readonly maxPresentationCommandBytes: number;
+    readonly maxPresentationQueryBytes: number;
+    readonly maxPresentationResponseBytes: number;
+    readonly maxPresentationSnapshotBytes: number;
+    readonly maxQueryBytes: number;
+    readonly maxQueryResponseBytes: number;
+    readonly maxSnapshotBytes: number;
+    readonly maxSpreadsheetCommandBytes: number;
+    readonly maxTextLayoutFontBundleBytes: number;
+    readonly maxTextLayoutRequestBytes: number;
+    readonly maxTextLayoutResponseBytes: number;
+    readonly maxViewportArea: number;
+    readonly maxViewportCells: number;
+    readonly safeRust: true;
+    readonly sessionForks: true;
+    readonly statefulSessions: true;
+    readonly transport: "bounded-uint8array";
+};
+export type ArtifactKernelPackageModule = {
+    readonly artifactKernelPackageIdentity: unknown;
+    readonly loadArtifactKernelBinding: () => unknown | Promise<unknown>;
+};
+export type ArtifactRuntimeModuleImporter = (specifier: string) => unknown | Promise<unknown>;
+export type ArtifactRuntimeErrorCode = "ARTIFACT_RUNTIME_INCOMPATIBLE" | "ARTIFACT_RUNTIME_INTEGRITY" | "ARTIFACT_RUNTIME_MANIFEST_INVALID" | "ARTIFACT_RUNTIME_UNAVAILABLE" | "ARTIFACT_RUNTIME_UNSUPPORTED_TARGET";
+export declare class ArtifactRuntimeError extends Error {
+    readonly code: ArtifactRuntimeErrorCode;
+    constructor(code: ArtifactRuntimeErrorCode, message: string, options?: ErrorOptions);
+}
+export declare function resolveArtifactRuntimeTarget(input: {
+    readonly platform: string;
+    readonly arch: string;
+    readonly libc?: ArtifactRuntimeLibc;
+}): ArtifactRuntimeTargetDescriptor;
+export declare function artifactRuntimeTarget(target: ArtifactRuntimeTarget): ArtifactRuntimeTargetDescriptor;
+export declare function validateArtifactKernelPackageManifest(value: unknown, expectedTarget?: ArtifactRuntimeTarget): ArtifactKernelPackageManifest;
+export declare function validateArtifactKernelPackageIdentity(value: unknown, expectedTarget?: ArtifactRuntimeTarget): ArtifactKernelPackageIdentity;
+export declare function validateArtifactRuntimeInstallationManifest(value: unknown, expectedTarget?: ArtifactRuntimeTarget): ArtifactRuntimeInstallationManifest;
+export declare function validateCompleteArtifactRuntimeReleaseManifest(value: unknown): ArtifactRuntimeReleaseManifest;
+export declare function locateArtifactRuntimeDependencies(value: unknown, manifestUrl: URL, expectedTarget?: ArtifactRuntimeTarget): ArtifactRuntimeDependencies;
+export declare function loadArtifactKernelRuntime(dependencies: ArtifactRuntimeKernelDependencies, importer?: ArtifactRuntimeModuleImporter): Promise<ArtifactKernelRuntime>;
+type RawCollaborationSession = {
+    authorTransaction(intent: Uint8Array, resolvedBase: Uint8Array): Uint8Array;
+    applyCommitted(operation: Uint8Array): void;
+    query(request: Uint8Array): Uint8Array;
+    snapshot(): Uint8Array;
+    frontier(): Uint8Array;
+    stateHash(): string;
+    revision(): bigint | number;
+    fork(): RawCollaborationSession;
+    close?(): void;
+    dispose?(): void;
+    free?(): void;
+    isClosed?(): boolean;
+    readonly closed?: boolean;
+};
+type RawModalitySession = {
+    applyCommands(commands: Uint8Array): Uint8Array;
+    query(request: Uint8Array): Uint8Array;
+    snapshot(): Uint8Array;
+    stateHash(): string;
+    revision(): bigint | number;
+    fork(): RawModalitySession;
+    close?(): void;
+    dispose?(): void;
+    free?(): void;
+    isClosed?(): boolean;
+    readonly closed?: boolean;
+};
+type RawTextLayoutSession = {
+    layout(request: Uint8Array): Uint8Array;
+    close?(): void;
+    dispose?(): void;
+    free?(): void;
+    isClosed?(): boolean;
+    readonly closed?: boolean;
+};
+export declare class ArtifactKernelRuntime {
+    #private;
+    readonly kind: ArtifactRuntimeKind;
+    readonly target: ArtifactRuntimeTarget;
+    readonly capabilities: ArtifactKernelCapabilities;
+    readonly buildIdentity: string;
+    constructor(kind: ArtifactRuntimeKind, candidate: unknown, packageManifest: ArtifactKernelPackageManifest);
+    canonicalizeCollaborationSnapshot(snapshot: Uint8Array): Uint8Array;
+    createDocument(namespace: bigint): Uint8Array;
+    applyDocumentCommands(snapshot: Uint8Array, commands: Uint8Array): Uint8Array;
+    queryDocument(snapshot: Uint8Array, query: Uint8Array): Uint8Array;
+    canonicalizeDocumentSnapshot(snapshot: Uint8Array): Uint8Array;
+    createPresentation(namespace: bigint): Uint8Array;
+    applyPresentationCommands(snapshot: Uint8Array, commands: Uint8Array): Uint8Array;
+    queryPresentation(snapshot: Uint8Array, query: Uint8Array): Uint8Array;
+    canonicalizePresentationSnapshot(snapshot: Uint8Array): Uint8Array;
+    layoutText(fontBundle: Uint8Array, request: Uint8Array): Uint8Array;
+    canonicalizeRenderTile(value: Uint8Array): Uint8Array;
+    canonicalizeRenderPatch(value: Uint8Array): Uint8Array;
+    createCollaborationSession(namespace: bigint): ArtifactCollaborationSession;
+    openCollaborationSession(snapshot: Uint8Array): ArtifactCollaborationSession;
+    createDocumentSession(namespace: bigint): ArtifactDocumentSession;
+    openDocumentSession(snapshot: Uint8Array): ArtifactDocumentSession;
+    createPresentationSession(namespace: bigint): ArtifactPresentationSession;
+    openPresentationSession(snapshot: Uint8Array): ArtifactPresentationSession;
+    openTextLayoutSession(fontBundle: Uint8Array): ArtifactTextLayoutSession;
+}
+export declare class ArtifactCollaborationSession {
+    #private;
+    constructor(session: RawCollaborationSession);
+    authorTransaction(intent: Uint8Array, resolvedBase: Uint8Array): Uint8Array;
+    applyCommitted(operation: Uint8Array): void;
+    queryViewport(request: Uint8Array): Uint8Array;
+    query(request: Uint8Array): Uint8Array;
+    snapshot(): Uint8Array;
+    frontier(): Uint8Array;
+    stateHash(): string;
+    revision(): bigint;
+    fork(): ArtifactCollaborationSession;
+    isClosed(): boolean;
+    dispose(): void;
+    private assertLive;
+}
+declare class ArtifactModalitySession {
+    #private;
+    constructor(session: RawModalitySession);
+    applyCommands(commands: Uint8Array): Uint8Array;
+    query(request: Uint8Array): Uint8Array;
+    snapshot(): Uint8Array;
+    revision(): bigint;
+    stateHash(): string;
+    isClosed(): boolean;
+    dispose(): void;
+    protected forkRaw(): RawModalitySession;
+    private assertLive;
+}
+/** Exact stateful N-API document session over OGADC/OGADQ/OGADOC bytes. */
+export declare class ArtifactDocumentSession extends ArtifactModalitySession {
+    fork(): ArtifactDocumentSession;
+}
+/** Exact stateful N-API presentation session over OGAPC/OGAPQ/OGAPS bytes. */
+export declare class ArtifactPresentationSession extends ArtifactModalitySession {
+    fork(): ArtifactPresentationSession;
+}
+/** Exact stateful N-API text-layout session with a retained validated font bundle. */
+export declare class ArtifactTextLayoutSession {
+    #private;
+    constructor(session: RawTextLayoutSession);
+    layout(request: Uint8Array): Uint8Array;
+    isClosed(): boolean;
+    dispose(): void;
+}
+export declare function encodeArtifactReplicaNamespace(namespace: bigint): Uint8Array;
+export {};

package/dist/runtime.js

@@ -0,0 +1,42 @@
+import {
+  ARTIFACT_RUNTIME_ENVIRONMENT,
+  ARTIFACT_RUNTIME_MATRIX,
+  ARTIFACT_RUNTIME_TARGETS,
+  ArtifactCollaborationSession,
+  ArtifactDocumentSession,
+  ArtifactKernelRuntime,
+  ArtifactPresentationSession,
+  ArtifactRuntimeError,
+  ArtifactTextLayoutSession,
+  artifactRuntimeTarget,
+  encodeArtifactReplicaNamespace,
+  loadArtifactKernelRuntime,
+  locateArtifactRuntimeDependencies,
+  resolveArtifactRuntimeTarget,
+  validateArtifactKernelPackageIdentity,
+  validateArtifactKernelPackageManifest,
+  validateArtifactRuntimeInstallationManifest,
+  validateCompleteArtifactRuntimeReleaseManifest
+} from "./chunk-N2IHNWBS.js";
+import "./chunk-VUNV25KB.js";
+export {
+  ARTIFACT_RUNTIME_ENVIRONMENT,
+  ARTIFACT_RUNTIME_MATRIX,
+  ARTIFACT_RUNTIME_TARGETS,
+  ArtifactCollaborationSession,
+  ArtifactDocumentSession,
+  ArtifactKernelRuntime,
+  ArtifactPresentationSession,
+  ArtifactRuntimeError,
+  ArtifactTextLayoutSession,
+  artifactRuntimeTarget,
+  encodeArtifactReplicaNamespace,
+  loadArtifactKernelRuntime,
+  locateArtifactRuntimeDependencies,
+  resolveArtifactRuntimeTarget,
+  validateArtifactKernelPackageIdentity,
+  validateArtifactKernelPackageManifest,
+  validateArtifactRuntimeInstallationManifest,
+  validateCompleteArtifactRuntimeReleaseManifest
+};
+//# sourceMappingURL=runtime.js.map

package/dist/runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/snapshot.d.ts

@@ -0,0 +1,26 @@
+import type { Document } from "./document.js";
+import type { Presentation } from "./presentation.js";
+import type { Workbook } from "./spreadsheet.js";
+type ArtifactSnapshotCommon = Readonly<{
+    schemaVersion: 1;
+    modality: "spreadsheet" | "document" | "presentation";
+    runtimeTarget: string;
+    kernelVersion: string;
+    modelSchemaVersion: 1;
+    snapshotVersion: 1;
+    stateHash: string;
+    snapshotBytes: Uint8Array;
+}>;
+/** Exact native-canonical state at one durable artifact boundary. */
+export type ArtifactSnapshot = (ArtifactSnapshotCommon & Readonly<{
+    modality: "spreadsheet";
+    coveredCausalFrontierBytes: Uint8Array;
+    operationProtocolVersion: 1;
+    crdtStateVersion: 1;
+}>) | (ArtifactSnapshotCommon & Readonly<{
+    modality: "document" | "presentation";
+    nativeRevision: number;
+}>);
+/** Capture one immutable native snapshot from an open artifact object. */
+export declare function createArtifactSnapshot(artifact: Workbook | Document | Presentation): ArtifactSnapshot;
+export {};