@opengeni/artifact-tool 0.2.2

package/dist/chunk-N2IHNWBS.js

@@ -0,0 +1,1002 @@
+// src/runtime.ts
+var ARTIFACT_RUNTIME_ENVIRONMENT = {
+  manifest: "OPENGENI_ARTIFACT_RUNTIME_MANIFEST",
+  toolEntrypoint: "OPENGENI_ARTIFACT_TOOL_ENTRY"
+};
+var ARTIFACT_RUNTIME_TARGETS = [
+  "darwin-x64",
+  "darwin-arm64",
+  "linux-x64-gnu",
+  "linux-arm64-gnu",
+  "linux-x64-musl",
+  "linux-arm64-musl",
+  "win32-x64-msvc",
+  "wasm-web"
+];
+var ARTIFACT_RUNTIME_MATRIX = [
+  descriptor("darwin-x64", "native", "darwin", "x64"),
+  descriptor("darwin-arm64", "native", "darwin", "arm64"),
+  descriptor("linux-x64-gnu", "native", "linux", "x64", "gnu"),
+  descriptor("linux-arm64-gnu", "native", "linux", "arm64", "gnu"),
+  descriptor("linux-x64-musl", "native", "linux", "x64", "musl"),
+  descriptor("linux-arm64-musl", "native", "linux", "arm64", "musl"),
+  descriptor("win32-x64-msvc", "native", "win32", "x64"),
+  descriptor("wasm-web", "wasm", "browser", "wasm32")
+];
+var ArtifactRuntimeError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(`[${code}] ${message}`, options);
+    this.name = "ArtifactRuntimeError";
+    this.code = code;
+  }
+};
+function resolveArtifactRuntimeTarget(input) {
+  const match = ARTIFACT_RUNTIME_MATRIX.find(
+    (entry) => entry.platform === input.platform && entry.arch === input.arch && (entry.platform !== "linux" || entry.libc === input.libc)
+  );
+  if (match) return match;
+  const libc = input.platform === "linux" ? `/${input.libc ?? "unknown-libc"}` : "";
+  throw new ArtifactRuntimeError(
+    "ARTIFACT_RUNTIME_UNSUPPORTED_TARGET",
+    `No artifact kernel is published for ${input.platform}/${input.arch}${libc}`
+  );
+}
+function artifactRuntimeTarget(target) {
+  const match = ARTIFACT_RUNTIME_MATRIX.find((entry) => entry.target === target);
+  if (!match) {
+    throw new ArtifactRuntimeError(
+      "ARTIFACT_RUNTIME_UNSUPPORTED_TARGET",
+      `Unknown artifact runtime target: ${String(target)}`
+    );
+  }
+  return match;
+}
+function validateArtifactKernelPackageManifest(value, expectedTarget) {
+  const record = exactRecord(
+    value,
+    [
+      "schemaVersion",
+      "target",
+      "kind",
+      "packageName",
+      "packageVersion",
+      "artifactToolVersion",
+      "buildIdentity",
+      "entrypoint",
+      "asset",
+      "supportFiles"
+    ],
+    "kernel package manifest"
+  );
+  if (record.schemaVersion !== 1) invalid("kernel package manifest schemaVersion must be 1");
+  if (!isArtifactRuntimeTarget(record.target)) invalid("kernel package manifest target is invalid");
+  const target = artifactRuntimeTarget(record.target);
+  if (expectedTarget !== void 0 && target.target !== expectedTarget) {
+    invalid(`kernel package target ${target.target} does not match ${expectedTarget}`);
+  }
+  if (record.kind !== target.kind) invalid("kernel package kind does not match its target");
+  if (record.packageName !== target.packageName) {
+    invalid("kernel package name does not match its target");
+  }
+  const packageVersion = exactStableVersion(record.packageVersion, "kernel package version");
+  const artifactToolVersion = exactStableVersion(
+    record.artifactToolVersion,
+    "artifact-tool compatibility version"
+  );
+  if (packageVersion !== artifactToolVersion) {
+    invalid("kernel and artifact-tool versions must be identical");
+  }
+  const buildIdentity = boundedString(record.buildIdentity, "kernel build identity", 512);
+  const entrypoint = exactRecord(
+    record.entrypoint,
+    ["path", "bytes", "sha256"],
+    "kernel entrypoint"
+  );
+  const asset = exactRecord(record.asset, ["path", "bytes", "sha256"], "kernel asset");
+  if (!Array.isArray(record.supportFiles) || record.supportFiles.length > 32) {
+    invalid("kernel supportFiles must be an array with at most 32 entries");
+  }
+  const supportFiles = record.supportFiles.map((supportFile, index) => {
+    const file = exactRecord(
+      supportFile,
+      ["path", "bytes", "sha256"],
+      `kernel support file ${index}`
+    );
+    return {
+      path: safeRelativePath(file.path, `kernel support file ${index} path`),
+      bytes: positiveSafeInteger(file.bytes, `kernel support file ${index} bytes`),
+      sha256: sha256(file.sha256, `kernel support file ${index} sha256`)
+    };
+  });
+  const runtimePaths = [entrypoint.path, asset.path, ...supportFiles.map((file) => file.path)];
+  if (new Set(runtimePaths).size !== runtimePaths.length) {
+    invalid("kernel runtime file paths must be unique");
+  }
+  if (!supportFiles.every((file, index) => index === 0 || supportFiles[index - 1].path < file.path)) {
+    invalid("kernel supportFiles must be strictly sorted by path");
+  }
+  return {
+    schemaVersion: 1,
+    target: target.target,
+    kind: target.kind,
+    packageName: target.packageName,
+    packageVersion,
+    artifactToolVersion,
+    buildIdentity,
+    entrypoint: {
+      path: safeRelativePath(entrypoint.path, "kernel entrypoint path"),
+      bytes: positiveSafeInteger(entrypoint.bytes, "kernel entrypoint bytes"),
+      sha256: sha256(entrypoint.sha256, "kernel entrypoint sha256")
+    },
+    asset: {
+      path: safeRelativePath(asset.path, "kernel asset path"),
+      bytes: positiveSafeInteger(asset.bytes, "kernel asset bytes"),
+      sha256: sha256(asset.sha256, "kernel asset sha256")
+    },
+    supportFiles
+  };
+}
+function validateArtifactKernelPackageIdentity(value, expectedTarget) {
+  const record = exactRecord(
+    value,
+    [
+      "schemaVersion",
+      "target",
+      "kind",
+      "packageName",
+      "packageVersion",
+      "artifactToolVersion",
+      "buildIdentity"
+    ],
+    "kernel package identity"
+  );
+  if (record.schemaVersion !== 1) invalid("kernel package identity schemaVersion must be 1");
+  if (!isArtifactRuntimeTarget(record.target)) invalid("kernel package identity target is invalid");
+  const target = artifactRuntimeTarget(record.target);
+  if (expectedTarget !== void 0 && target.target !== expectedTarget) {
+    invalid(`kernel package identity target ${target.target} does not match ${expectedTarget}`);
+  }
+  if (record.kind !== target.kind)
+    invalid("kernel package identity kind does not match its target");
+  if (record.packageName !== target.packageName) {
+    invalid("kernel package identity name does not match its target");
+  }
+  const packageVersion = exactStableVersion(
+    record.packageVersion,
+    "kernel package identity version"
+  );
+  const artifactToolVersion = exactStableVersion(
+    record.artifactToolVersion,
+    "kernel package identity artifact-tool version"
+  );
+  if (packageVersion !== artifactToolVersion) {
+    invalid("kernel package identity versions must be identical");
+  }
+  return {
+    schemaVersion: 1,
+    target: target.target,
+    kind: target.kind,
+    packageName: target.packageName,
+    packageVersion,
+    artifactToolVersion,
+    buildIdentity: boundedString(
+      record.buildIdentity,
+      "kernel package identity build identity",
+      512
+    )
+  };
+}
+function validateArtifactRuntimeInstallationManifest(value, expectedTarget) {
+  const candidate = requiredRecord(value, "artifact runtime installation manifest");
+  const record = exactRecord(
+    candidate,
+    [
+      "schemaVersion",
+      "target",
+      "releaseManifest",
+      "artifactTool",
+      ...Object.hasOwn(candidate, "artifactToolArchive") ? ["artifactToolArchive"] : [],
+      "skillFacadeEntrypoint",
+      ...Object.hasOwn(candidate, "skillFacadeSupportFiles") ? ["skillFacadeSupportFiles"] : [],
+      "kernelPackageRoot",
+      "kernel"
+    ],
+    "artifact runtime installation manifest"
+  );
+  if (record.schemaVersion !== 1) invalid("installation manifest schemaVersion must be 1");
+  if (!isArtifactRuntimeTarget(record.target)) invalid("installation manifest target is invalid");
+  if (expectedTarget !== void 0 && record.target !== expectedTarget) {
+    invalid(`installation target ${record.target} does not match ${expectedTarget}`);
+  }
+  const releaseManifest = exactRecord(
+    record.releaseManifest,
+    ["path", "bytes", "sha256"],
+    "release manifest file"
+  );
+  const artifactTool = exactRecord(
+    record.artifactTool,
+    ["packageName", "packageVersion", "integrity"],
+    "artifact-tool installation"
+  );
+  if (artifactTool.packageName !== "@opengeni/artifact-tool") {
+    invalid("artifact-tool package name is invalid");
+  }
+  const packageVersion = exactStableVersion(artifactTool.packageVersion, "artifact-tool version");
+  const integrity = sha512Integrity(artifactTool.integrity, "artifact-tool integrity");
+  const artifactToolArchive = Object.hasOwn(candidate, "artifactToolArchive") ? exactRecord(record.artifactToolArchive, ["path", "bytes", "sha256"], "artifact-tool archive") : void 0;
+  const skillFacadeEntrypoint = exactRecord(
+    record.skillFacadeEntrypoint,
+    ["path", "bytes", "sha256"],
+    "skill facade entrypoint"
+  );
+  const rawSkillFacadeSupportFiles = record.skillFacadeSupportFiles ?? [];
+  if (!Array.isArray(rawSkillFacadeSupportFiles) || rawSkillFacadeSupportFiles.length > 256) {
+    invalid("skill facade supportFiles must be an array with at most 256 entries");
+  }
+  const skillFacadeSupportFiles = rawSkillFacadeSupportFiles.map((supportFile, index) => {
+    const file = exactRecord(
+      supportFile,
+      ["path", "bytes", "sha256"],
+      `skill facade support file ${index}`
+    );
+    return {
+      path: safeRelativePath(file.path, `skill facade support file ${index} path`),
+      bytes: positiveSafeInteger(file.bytes, `skill facade support file ${index} bytes`),
+      sha256: sha256(file.sha256, `skill facade support file ${index} sha256`)
+    };
+  });
+  if (!skillFacadeSupportFiles.every(
+    (file, index) => index === 0 || skillFacadeSupportFiles[index - 1].path < file.path
+  )) {
+    invalid("skill facade supportFiles must be strictly sorted by path");
+  }
+  const facadeRuntimePaths = [
+    ...artifactToolArchive ? [safeRelativePath(artifactToolArchive.path, "artifact-tool archive path")] : [],
+    safeRelativePath(releaseManifest.path, "release manifest path"),
+    safeRelativePath(skillFacadeEntrypoint.path, "skill facade entrypoint path"),
+    ...skillFacadeSupportFiles.map((file) => file.path)
+  ];
+  const skillFacadeSupportBytes = skillFacadeSupportFiles.reduce(
+    (total, file) => total + file.bytes,
+    0
+  );
+  if (!Number.isSafeInteger(skillFacadeSupportBytes) || skillFacadeSupportBytes > 256 * 1024 * 1024) {
+    invalid("skill facade supportFiles exceed the 256 MiB installation limit");
+  }
+  const kernel = validateArtifactKernelPackageManifest(record.kernel, record.target);
+  if (kernel.artifactToolVersion !== packageVersion) {
+    invalid("installed artifact-tool and kernel versions must be identical");
+  }
+  const kernelPackageRoot = safeRelativePath(record.kernelPackageRoot, "kernel package root");
+  const installationFilePaths = [
+    ...facadeRuntimePaths,
+    `${kernelPackageRoot}/${kernel.entrypoint.path}`,
+    `${kernelPackageRoot}/${kernel.asset.path}`,
+    ...kernel.supportFiles.map((file) => `${kernelPackageRoot}/${file.path}`)
+  ].sort();
+  if (installationFilePaths.some(
+    (path, index) => index > 0 && (path === installationFilePaths[index - 1] || path.startsWith(`${installationFilePaths[index - 1]}/`))
+  )) {
+    invalid("installation runtime file paths must be collision-free");
+  }
+  return {
+    schemaVersion: 1,
+    target: record.target,
+    releaseManifest: {
+      path: safeRelativePath(releaseManifest.path, "release manifest path"),
+      bytes: positiveSafeInteger(releaseManifest.bytes, "release manifest bytes"),
+      sha256: sha256(releaseManifest.sha256, "release manifest sha256")
+    },
+    artifactTool: {
+      packageName: "@opengeni/artifact-tool",
+      packageVersion,
+      integrity
+    },
+    ...artifactToolArchive ? {
+      artifactToolArchive: {
+        path: safeRelativePath(artifactToolArchive.path, "artifact-tool archive path"),
+        bytes: positiveSafeInteger(artifactToolArchive.bytes, "artifact-tool archive bytes"),
+        sha256: sha256(artifactToolArchive.sha256, "artifact-tool archive sha256")
+      }
+    } : {},
+    skillFacadeEntrypoint: {
+      path: safeRelativePath(skillFacadeEntrypoint.path, "skill facade entrypoint path"),
+      bytes: positiveSafeInteger(skillFacadeEntrypoint.bytes, "skill facade entrypoint bytes"),
+      sha256: sha256(skillFacadeEntrypoint.sha256, "skill facade entrypoint sha256")
+    },
+    ...Object.hasOwn(candidate, "skillFacadeSupportFiles") ? { skillFacadeSupportFiles } : {},
+    kernelPackageRoot,
+    kernel: {
+      ...kernel
+    }
+  };
+}
+function validateCompleteArtifactRuntimeReleaseManifest(value) {
+  const record = exactRecord(
+    value,
+    ["schemaVersion", "artifactTool", "targets"],
+    "release manifest"
+  );
+  if (record.schemaVersion !== 1) invalid("release manifest schemaVersion must be 1");
+  const artifactTool = exactRecord(
+    record.artifactTool,
+    ["packageName", "packageVersion", "integrity"],
+    "release artifact-tool"
+  );
+  if (artifactTool.packageName !== "@opengeni/artifact-tool") {
+    invalid("release artifact-tool package name is invalid");
+  }
+  const packageVersion = exactStableVersion(
+    artifactTool.packageVersion,
+    "release artifact-tool version"
+  );
+  const integrity = sha512Integrity(artifactTool.integrity, "release artifact-tool integrity");
+  if (!Array.isArray(record.targets)) invalid("release targets must be an array");
+  if (record.targets.length !== ARTIFACT_RUNTIME_MATRIX.length) {
+    invalid(`release manifest must contain exactly ${ARTIFACT_RUNTIME_MATRIX.length} targets`);
+  }
+  const targets = record.targets.map((entry, index) => {
+    const expected = ARTIFACT_RUNTIME_MATRIX[index];
+    const target = validateArtifactKernelPackageManifest(entry, expected.target);
+    if (target.artifactToolVersion !== packageVersion) {
+      invalid(`target ${target.target} does not match artifact-tool ${packageVersion}`);
+    }
+    return target;
+  });
+  const buildIdentities = new Set(targets.map((target) => target.buildIdentity));
+  if (buildIdentities.size !== 1) invalid("all target packages must carry one build identity");
+  return {
+    schemaVersion: 1,
+    artifactTool: {
+      packageName: "@opengeni/artifact-tool",
+      packageVersion,
+      integrity
+    },
+    targets
+  };
+}
+function locateArtifactRuntimeDependencies(value, manifestUrl, expectedTarget) {
+  if (manifestUrl.protocol !== "file:") {
+    throw new ArtifactRuntimeError(
+      "ARTIFACT_RUNTIME_MANIFEST_INVALID",
+      "Installed runtime manifest must be a local file URL"
+    );
+  }
+  const manifest = validateArtifactRuntimeInstallationManifest(value, expectedTarget);
+  const root = new URL("./", manifestUrl);
+  const kernelRoot = confinedUrl(root, `${manifest.kernelPackageRoot}/`);
+  return {
+    target: artifactRuntimeTarget(manifest.target),
+    manifestUrl,
+    releaseManifestUrl: confinedUrl(root, manifest.releaseManifest.path),
+    ...manifest.artifactToolArchive ? { artifactToolArchiveUrl: confinedUrl(root, manifest.artifactToolArchive.path) } : {},
+    skillFacadeEntrypoint: confinedUrl(root, manifest.skillFacadeEntrypoint.path),
+    skillFacadeSupportFiles: (manifest.skillFacadeSupportFiles ?? []).map(
+      (file) => confinedUrl(root, file.path)
+    ),
+    kernelEntrypoint: confinedUrl(kernelRoot, manifest.kernel.entrypoint.path),
+    kernelAsset: confinedUrl(kernelRoot, manifest.kernel.asset.path),
+    kernelSupportFiles: manifest.kernel.supportFiles.map(
+      (file) => confinedUrl(kernelRoot, file.path)
+    ),
+    manifest
+  };
+}
+async function loadArtifactKernelRuntime(dependencies, importer = defaultModuleImporter) {
+  let imported;
+  try {
+    imported = await importer(dependencies.kernelEntrypoint.href);
+  } catch (cause) {
+    throw new ArtifactRuntimeError(
+      "ARTIFACT_RUNTIME_UNAVAILABLE",
+      `Could not load exact kernel package ${dependencies.manifest.kernel.packageName}`,
+      { cause }
+    );
+  }
+  const module = requiredRecord(imported, "kernel package module");
+  const packagedIdentity = validateArtifactKernelPackageIdentity(
+    module.artifactKernelPackageIdentity,
+    dependencies.target.target
+  );
+  assertSameKernelPackageIdentity(packagedIdentity, dependencies.manifest.kernel);
+  if (typeof module.loadArtifactKernelBinding !== "function") {
+    incompatible("kernel package does not export loadArtifactKernelBinding()");
+  }
+  const candidate = await module.loadArtifactKernelBinding();
+  return new ArtifactKernelRuntime(
+    dependencies.target.kind,
+    candidate,
+    dependencies.manifest.kernel
+  );
+}
+var ArtifactKernelRuntime = class {
+  kind;
+  target;
+  capabilities;
+  buildIdentity;
+  #binding;
+  constructor(kind, candidate, packageManifest) {
+    const manifest = validateArtifactKernelPackageManifest(packageManifest);
+    if (kind !== manifest.kind) incompatible("binding kind does not match package manifest");
+    this.kind = kind;
+    this.target = manifest.target;
+    this.#binding = validateRawBinding(candidate);
+    this.capabilities = parseCapabilities(this.#binding.capabilities());
+    this.buildIdentity = decodeBuildIdentity(this.#binding.buildIdentity());
+    if (this.buildIdentity !== manifest.buildIdentity) {
+      throw new ArtifactRuntimeError(
+        "ARTIFACT_RUNTIME_INTEGRITY",
+        "Loaded kernel build identity does not match its package manifest"
+      );
+    }
+  }
+  canonicalizeCollaborationSnapshot(snapshot) {
+    return bytes(
+      this.#binding.canonicalizeCollaborationSnapshot(snapshot),
+      "canonicalizeCollaborationSnapshot"
+    );
+  }
+  createDocument(namespace) {
+    return bytes(
+      this.#binding.createDocument(encodeArtifactReplicaNamespace(namespace)),
+      "createDocument"
+    );
+  }
+  applyDocumentCommands(snapshot, commands) {
+    return bytes(this.#binding.applyDocumentCommands(snapshot, commands), "applyDocumentCommands");
+  }
+  queryDocument(snapshot, query) {
+    return bytes(this.#binding.queryDocument(snapshot, query), "queryDocument");
+  }
+  canonicalizeDocumentSnapshot(snapshot) {
+    return bytes(
+      this.#binding.canonicalizeDocumentSnapshot(snapshot),
+      "canonicalizeDocumentSnapshot"
+    );
+  }
+  createPresentation(namespace) {
+    return bytes(
+      this.#binding.createPresentation(encodeArtifactReplicaNamespace(namespace)),
+      "createPresentation"
+    );
+  }
+  applyPresentationCommands(snapshot, commands) {
+    return bytes(
+      this.#binding.applyPresentationCommands(snapshot, commands),
+      "applyPresentationCommands"
+    );
+  }
+  queryPresentation(snapshot, query) {
+    return bytes(this.#binding.queryPresentation(snapshot, query), "queryPresentation");
+  }
+  canonicalizePresentationSnapshot(snapshot) {
+    return bytes(
+      this.#binding.canonicalizePresentationSnapshot(snapshot),
+      "canonicalizePresentationSnapshot"
+    );
+  }
+  layoutText(fontBundle, request) {
+    return bytes(this.#binding.layoutText(fontBundle, request), "layoutText");
+  }
+  canonicalizeRenderTile(value) {
+    return bytes(this.#binding.canonicalizeRenderTile(value), "canonicalizeRenderTile");
+  }
+  canonicalizeRenderPatch(value) {
+    return bytes(this.#binding.canonicalizeRenderPatch(value), "canonicalizeRenderPatch");
+  }
+  createCollaborationSession(namespace) {
+    return new ArtifactCollaborationSession(
+      this.#binding.ArtifactCollaborationSession.create(encodeArtifactReplicaNamespace(namespace))
+    );
+  }
+  openCollaborationSession(snapshot) {
+    return new ArtifactCollaborationSession(
+      this.#binding.ArtifactCollaborationSession.open(snapshot)
+    );
+  }
+  createDocumentSession(namespace) {
+    return new ArtifactDocumentSession(
+      this.#binding.ArtifactDocumentSession.create(encodeArtifactReplicaNamespace(namespace))
+    );
+  }
+  openDocumentSession(snapshot) {
+    return new ArtifactDocumentSession(this.#binding.ArtifactDocumentSession.open(snapshot));
+  }
+  createPresentationSession(namespace) {
+    return new ArtifactPresentationSession(
+      this.#binding.ArtifactPresentationSession.create(encodeArtifactReplicaNamespace(namespace))
+    );
+  }
+  openPresentationSession(snapshot) {
+    return new ArtifactPresentationSession(
+      this.#binding.ArtifactPresentationSession.open(snapshot)
+    );
+  }
+  openTextLayoutSession(fontBundle) {
+    return new ArtifactTextLayoutSession(this.#binding.ArtifactTextLayoutSession.open(fontBundle));
+  }
+};
+var ArtifactCollaborationSession = class _ArtifactCollaborationSession {
+  #session;
+  #disposed = false;
+  constructor(session) {
+    validateRawCollaborationSession(session);
+    this.#session = session;
+  }
+  authorTransaction(intent, resolvedBase) {
+    this.assertLive();
+    return bytes(this.#session.authorTransaction(intent, resolvedBase), "authorTransaction");
+  }
+  applyCommitted(operation) {
+    this.assertLive();
+    this.#session.applyCommitted(operation);
+  }
+  queryViewport(request) {
+    return this.query(request);
+  }
+  query(request) {
+    this.assertLive();
+    return bytes(this.#session.query(request), "query");
+  }
+  snapshot() {
+    this.assertLive();
+    return bytes(this.#session.snapshot(), "snapshot");
+  }
+  frontier() {
+    this.assertLive();
+    return bytes(this.#session.frontier(), "frontier");
+  }
+  stateHash() {
+    this.assertLive();
+    const returnedStateHash = this.#session.stateHash();
+    if (!/^sha256:[0-9a-f]{64}$/u.test(returnedStateHash))
+      incompatible("kernel returned invalid state hash");
+    return returnedStateHash;
+  }
+  revision() {
+    this.assertLive();
+    const revision = this.#session.revision();
+    if (typeof revision === "bigint") {
+      if (revision < 0n) incompatible("kernel returned a negative revision");
+      return revision;
+    }
+    if (!Number.isSafeInteger(revision) || revision < 0) {
+      incompatible("kernel returned an unsafe revision");
+    }
+    return BigInt(revision);
+  }
+  fork() {
+    this.assertLive();
+    return new _ArtifactCollaborationSession(this.#session.fork());
+  }
+  isClosed() {
+    return this.#disposed || (typeof this.#session.isClosed === "function" ? this.#session.isClosed() : this.#session.closed === true);
+  }
+  dispose() {
+    if (this.#disposed) return;
+    try {
+      if (!this.isClosed()) {
+        if (typeof this.#session.dispose === "function") this.#session.dispose();
+        else this.#session.close?.();
+      }
+    } finally {
+      this.#session.free?.();
+      this.#disposed = true;
+    }
+  }
+  assertLive() {
+    if (this.isClosed()) incompatible("artifact collaboration session is closed");
+  }
+};
+var ArtifactModalitySession = class {
+  #session;
+  #disposed = false;
+  constructor(session) {
+    validateRawModalitySession(session);
+    this.#session = session;
+  }
+  applyCommands(commands) {
+    this.assertLive();
+    return bytes(this.#session.applyCommands(commands), "modality session applyCommands");
+  }
+  query(request) {
+    this.assertLive();
+    return bytes(this.#session.query(request), "modality session query");
+  }
+  snapshot() {
+    this.assertLive();
+    return bytes(this.#session.snapshot(), "modality session snapshot");
+  }
+  revision() {
+    this.assertLive();
+    return safeRevision(this.#session.revision());
+  }
+  stateHash() {
+    this.assertLive();
+    return stateHash(this.#session.stateHash());
+  }
+  isClosed() {
+    return rawSessionClosed(this.#disposed, this.#session);
+  }
+  dispose() {
+    if (this.#disposed) return;
+    try {
+      if (!this.isClosed()) {
+        if (typeof this.#session.dispose === "function") this.#session.dispose();
+        else this.#session.close?.();
+      }
+    } finally {
+      this.#session.free?.();
+      this.#disposed = true;
+    }
+  }
+  forkRaw() {
+    this.assertLive();
+    return this.#session.fork();
+  }
+  assertLive() {
+    if (this.isClosed()) incompatible("artifact modality session is closed");
+  }
+};
+var ArtifactDocumentSession = class _ArtifactDocumentSession extends ArtifactModalitySession {
+  fork() {
+    return new _ArtifactDocumentSession(this.forkRaw());
+  }
+};
+var ArtifactPresentationSession = class _ArtifactPresentationSession extends ArtifactModalitySession {
+  fork() {
+    return new _ArtifactPresentationSession(this.forkRaw());
+  }
+};
+var ArtifactTextLayoutSession = class {
+  #session;
+  #disposed = false;
+  constructor(session) {
+    validateRawTextLayoutSession(session);
+    this.#session = session;
+  }
+  layout(request) {
+    if (this.isClosed()) incompatible("artifact text-layout session is closed");
+    return bytes(this.#session.layout(request), "text-layout session layout");
+  }
+  isClosed() {
+    return rawSessionClosed(this.#disposed, this.#session);
+  }
+  dispose() {
+    if (this.#disposed) return;
+    try {
+      if (!this.isClosed()) {
+        if (typeof this.#session.dispose === "function") this.#session.dispose();
+        else this.#session.close?.();
+      }
+    } finally {
+      this.#session.free?.();
+      this.#disposed = true;
+    }
+  }
+};
+function descriptor(target, kind, platform, arch, libc) {
+  return {
+    target,
+    kind,
+    packageName: `@opengeni/artifact-kernel-${target}`,
+    platform,
+    arch,
+    ...libc ? { libc } : {}
+  };
+}
+function defaultModuleImporter(specifier) {
+  return import(
+    /* @vite-ignore */
+    specifier
+  );
+}
+function validateRawBinding(value) {
+  const binding = bindingRecord(value, "artifact kernel binding");
+  for (const name of [
+    "capabilities",
+    "buildIdentity",
+    "canonicalizeCollaborationSnapshot",
+    "createDocument",
+    "applyDocumentCommands",
+    "queryDocument",
+    "canonicalizeDocumentSnapshot",
+    "createPresentation",
+    "applyPresentationCommands",
+    "queryPresentation",
+    "canonicalizePresentationSnapshot",
+    "layoutText",
+    "canonicalizeRenderTile",
+    "canonicalizeRenderPatch"
+  ]) {
+    if (typeof binding[name] !== "function") incompatible(`kernel binding is missing ${name}()`);
+  }
+  const session = bindingRecord(
+    binding.ArtifactCollaborationSession,
+    "ArtifactCollaborationSession"
+  );
+  if (typeof session.create !== "function" || typeof session.open !== "function") {
+    incompatible("ArtifactCollaborationSession is missing create/open factories");
+  }
+  for (const name of ["ArtifactDocumentSession", "ArtifactPresentationSession"]) {
+    const constructor = bindingRecord(binding[name], name);
+    if (typeof constructor.create !== "function" || typeof constructor.open !== "function") {
+      incompatible(`${name} is missing create/open factories`);
+    }
+  }
+  const textLayout = bindingRecord(binding.ArtifactTextLayoutSession, "ArtifactTextLayoutSession");
+  if (typeof textLayout.open !== "function") {
+    incompatible("ArtifactTextLayoutSession is missing open() factory");
+  }
+  return value;
+}
+function validateRawCollaborationSession(value) {
+  const session = bindingRecord(value, "artifact collaboration session");
+  for (const name of [
+    "authorTransaction",
+    "applyCommitted",
+    "query",
+    "snapshot",
+    "frontier",
+    "stateHash",
+    "revision",
+    "fork"
+  ]) {
+    if (typeof session[name] !== "function")
+      incompatible(`collaboration session is missing ${name}()`);
+  }
+}
+function validateRawModalitySession(value) {
+  const session = bindingRecord(value, "artifact modality session");
+  for (const name of [
+    "applyCommands",
+    "query",
+    "snapshot",
+    "stateHash",
+    "revision",
+    "fork"
+  ]) {
+    if (typeof session[name] !== "function") {
+      incompatible(`artifact modality session is missing ${name}()`);
+    }
+  }
+}
+function validateRawTextLayoutSession(value) {
+  const session = bindingRecord(value, "artifact text-layout session");
+  if (typeof session.layout !== "function") {
+    incompatible("artifact text-layout session is missing layout()");
+  }
+}
+function parseCapabilities(value) {
+  const decoded = JSON.parse(
+    new TextDecoder("utf-8", { fatal: true }).decode(bytes(value, "capabilities"))
+  );
+  const capabilities = requiredRecord(decoded, "artifact kernel capabilities");
+  const required = {
+    abiVersion: 1,
+    buildIdentityFormat: "utf8",
+    commandSchemaVersion: 1,
+    spreadsheetCommandVersion: 1,
+    kernelSnapshotVersion: 1,
+    receiptSchemaVersion: 1,
+    collaborationSnapshotVersion: 1,
+    editableArtifactIntentVersion: 1,
+    committedTransactionVersion: 1,
+    queryVersion: 1,
+    queryResponseVersion: 1,
+    collaboration: true,
+    document: true,
+    documentCommandVersion: 1,
+    documentQueryResponseVersion: 1,
+    documentQueryVersion: 1,
+    documentReceiptVersion: 1,
+    documentSnapshotVersion: 1,
+    documentStatefulSessions: true,
+    presentation: true,
+    presentationCommandVersion: 1,
+    presentationQueryResponseVersion: 1,
+    presentationQueryVersion: 1,
+    presentationSnapshotVersion: 1,
+    presentationStatefulSessions: true,
+    textLayout: true,
+    textLayoutFontBundleVersion: 1,
+    textLayoutRequestVersion: 1,
+    textLayoutResponseVersion: 1,
+    textLayoutStatefulSessions: true,
+    retainedRenderPatchVersion: 1,
+    retainedRenderTileVersion: 1,
+    workbookMetadataQueries: true,
+    canonicalStateHash: "sha256:canonical-snapshot",
+    safeRust: true,
+    sessionForks: true,
+    statefulSessions: true,
+    transport: "bounded-uint8array"
+  };
+  for (const [name, expected] of Object.entries(required)) {
+    if (capabilities[name] !== expected) incompatible(`kernel capability ${name} is incompatible`);
+  }
+  for (const name of [
+    "maxCellsPerBatch",
+    "maxCommandBytes",
+    "maxCommands",
+    "maxCommittedTransactionBytes",
+    "maxDocumentCommandBytes",
+    "maxDocumentCommands",
+    "maxDocumentQueryBytes",
+    "maxDocumentQueryResponseBytes",
+    "maxDocumentSnapshotBytes",
+    "maxIntentBytes",
+    "maxMetadataScannedCells",
+    "maxMetadataSheets",
+    "maxPresentationCommandBytes",
+    "maxPresentationQueryBytes",
+    "maxPresentationResponseBytes",
+    "maxPresentationSnapshotBytes",
+    "maxQueryBytes",
+    "maxQueryResponseBytes",
+    "maxSnapshotBytes",
+    "maxSpreadsheetCommandBytes",
+    "maxTextLayoutFontBundleBytes",
+    "maxTextLayoutRequestBytes",
+    "maxTextLayoutResponseBytes",
+    "maxViewportArea",
+    "maxViewportCells"
+  ]) {
+    positiveSafeInteger(capabilities[name], `kernel capability ${name}`);
+  }
+  return capabilities;
+}
+function decodeBuildIdentity(value) {
+  const identity = new TextDecoder("utf-8", { fatal: true }).decode(bytes(value, "buildIdentity"));
+  return boundedString(identity, "kernel build identity", 512);
+}
+function safeRevision(value) {
+  if (typeof value === "bigint") {
+    if (value < 0n) incompatible("kernel returned a negative revision");
+    return value;
+  }
+  if (!Number.isSafeInteger(value) || value < 0) {
+    incompatible("kernel returned an unsafe revision");
+  }
+  return BigInt(value);
+}
+function stateHash(value) {
+  if (!/^sha256:[0-9a-f]{64}$/u.test(value)) incompatible("kernel returned invalid state hash");
+  return value;
+}
+function rawSessionClosed(disposed, session) {
+  return disposed || (typeof session.isClosed === "function" ? session.isClosed() : session.closed === true);
+}
+function encodeArtifactReplicaNamespace(namespace) {
+  if (namespace <= 0n || namespace > 0xffffffffffffffffn) {
+    incompatible("artifact replica namespace must be a nonzero u64");
+  }
+  const envelope = new Uint8Array(28);
+  envelope.set(new TextEncoder().encode("OGAKN001"));
+  const view = new DataView(envelope.buffer);
+  view.setUint16(8, 1, true);
+  view.setBigUint64(12, namespace, true);
+  view.setBigUint64(20, fnv64(envelope.subarray(0, 20)), true);
+  return envelope;
+}
+function fnv64(value) {
+  let hash = 0xcbf29ce484222325n;
+  for (const byte of value) {
+    hash ^= BigInt(byte);
+    hash = BigInt.asUintN(64, hash * 0x100000001b3n);
+  }
+  return hash;
+}
+function assertSameKernelPackageIdentity(actual, expected) {
+  if (JSON.stringify(actual) !== JSON.stringify({
+    schemaVersion: expected.schemaVersion,
+    target: expected.target,
+    kind: expected.kind,
+    packageName: expected.packageName,
+    packageVersion: expected.packageVersion,
+    artifactToolVersion: expected.artifactToolVersion,
+    buildIdentity: expected.buildIdentity
+  })) {
+    throw new ArtifactRuntimeError(
+      "ARTIFACT_RUNTIME_INTEGRITY",
+      "Loaded kernel package identity differs from the installation manifest"
+    );
+  }
+}
+function confinedUrl(root, relativePath) {
+  const candidate = new URL(relativePath, root);
+  if (candidate.protocol !== "file:" || !candidate.href.startsWith(root.href)) {
+    invalid("runtime dependency escapes the installation root");
+  }
+  return candidate;
+}
+function safeRelativePath(value, name) {
+  const path = boundedString(value, name, 1024);
+  if (path.startsWith("/") || path.startsWith("\\") || path.includes("\\") || path.split("/").some((part) => part === "" || part === "." || part === "..") || /[%?#\0]/u.test(path)) {
+    invalid(`${name} must be a normalized relative POSIX path`);
+  }
+  return path;
+}
+function exactStableVersion(value, name) {
+  if (typeof value !== "string" || !/^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)$/u.test(value)) {
+    invalid(`${name} must be an exact stable semantic version`);
+  }
+  return value;
+}
+function sha256(value, name) {
+  if (typeof value !== "string" || !/^sha256:[0-9a-f]{64}$/u.test(value)) {
+    invalid(`${name} must be a lowercase SHA-256 digest`);
+  }
+  return value;
+}
+function sha512Integrity(value, name) {
+  if (typeof value !== "string" || !/^sha512-[A-Za-z0-9+/]+={0,2}$/u.test(value)) {
+    invalid(`${name} is invalid`);
+  }
+  return value;
+}
+function positiveSafeInteger(value, name) {
+  if (!Number.isSafeInteger(value) || value <= 0) invalid(`${name} must be positive`);
+  return value;
+}
+function boundedString(value, name, maximum) {
+  if (typeof value !== "string" || value.length === 0 || value.length > maximum) {
+    invalid(`${name} is invalid`);
+  }
+  return value;
+}
+function isArtifactRuntimeTarget(value) {
+  return typeof value === "string" && ARTIFACT_RUNTIME_TARGETS.includes(value);
+}
+function exactRecord(value, keys, name) {
+  const record = requiredRecord(value, name);
+  const actualKeys = Object.keys(record).sort();
+  const expectedKeys = [...keys].sort();
+  if (JSON.stringify(actualKeys) !== JSON.stringify(expectedKeys))
+    invalid(`${name} has unexpected fields`);
+  return record;
+}
+function requiredRecord(value, name) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    invalid(`${name} is invalid`);
+  return value;
+}
+function bindingRecord(value, name) {
+  if (typeof value !== "object" && typeof value !== "function" || value === null) {
+    incompatible(`${name} is invalid`);
+  }
+  return value;
+}
+function bytes(value, name) {
+  if (!(value instanceof Uint8Array)) incompatible(`kernel ${name} did not return Uint8Array`);
+  return value;
+}
+function invalid(message) {
+  throw new ArtifactRuntimeError("ARTIFACT_RUNTIME_MANIFEST_INVALID", message);
+}
+function incompatible(message) {
+  throw new ArtifactRuntimeError("ARTIFACT_RUNTIME_INCOMPATIBLE", message);
+}
+
+export {
+  ARTIFACT_RUNTIME_ENVIRONMENT,
+  ARTIFACT_RUNTIME_TARGETS,
+  ARTIFACT_RUNTIME_MATRIX,
+  ArtifactRuntimeError,
+  resolveArtifactRuntimeTarget,
+  artifactRuntimeTarget,
+  validateArtifactKernelPackageManifest,
+  validateArtifactKernelPackageIdentity,
+  validateArtifactRuntimeInstallationManifest,
+  validateCompleteArtifactRuntimeReleaseManifest,
+  locateArtifactRuntimeDependencies,
+  loadArtifactKernelRuntime,
+  ArtifactKernelRuntime,
+  ArtifactCollaborationSession,
+  ArtifactDocumentSession,
+  ArtifactPresentationSession,
+  ArtifactTextLayoutSession,
+  encodeArtifactReplicaNamespace
+};
+//# sourceMappingURL=chunk-N2IHNWBS.js.map