@airalogy/aira-core 0.1.0 → 0.3.0

package/README.md

@@ -2,12 +2,16 @@
 
 Core TypeScript parser and validator for Airalogy `.aira` archives.
 
-It opens `.aira` files in browser-compatible JavaScript, reads `_airalogy_archive/manifest.json`, lists archive members, loads JSON/text payloads, and validates manifest references, Record hashes, Protocol file hashes, and offline blob hashes.
+It opens `.aira` files in browser-compatible JavaScript, reads `_airalogy_archive/manifest.json`, lists archive members, loads JSON/text payloads, and validates manifest references, Record payload structure, Record hashes, Protocol file hashes, and offline blob hashes.
+
+It can also create single-Protocol `.aira` archives in the browser. This is useful for editors that let users attach protocol-local assets such as `files/workflow-diagram.svg` and reference them from AIMD `fig` blocks.
 
 Supported archive kinds are `protocol`, `protocols`, and `records`.
 
 Example archives covering these kinds are available in `examples/aira/`.
 
+The public manifest schema is available at `schemas/aira/manifest.v1.schema.json`; the public Record schema is available at `schemas/aira/record.v1.schema.json`.
+
 ```ts
 import { openAiraArchive } from '@airalogy/aira-core'
 
@@ -17,4 +21,29 @@ const validation = await archive.validate()
 const manifest = archive.manifest
 ```
 
+Create a Protocol archive with protocol-local figure files:
+
+```ts
+import { createProtocolAiraArchive } from '@airalogy/aira-core'
+
+const bytes = await createProtocolAiraArchive({
+  aimd: [
+    '# Figure Protocol',
+    '',
+    '```fig',
+    'id: workflow_diagram',
+    'src: files/workflow-diagram.svg',
+    'title: Workflow Diagram',
+    '```',
+    '',
+  ].join('\n'),
+  files: [
+    {
+      path: 'files/workflow-diagram.svg',
+      data: svgFile,
+    },
+  ],
+})
+```
+
 `.aira` archives are standard ZIP containers. The core package keeps reading independent from the full Airalogy platform, database, or execution engine.

package/dist/index.d.ts

@@ -0,0 +1,129 @@
+export declare const AIRA_MANIFEST_PATH = "_airalogy_archive/manifest.json";
+export declare const AIRA_ARCHIVE_FORMAT = "airalogy.archive";
+export declare const AIRALOGY_RECORD_FORMAT = "airalogy.record";
+export declare const AIRALOGY_RECORD_SCHEMA_VERSION = 1;
+export type AiraArchiveKind = 'protocol' | 'protocols' | 'records';
+export interface AiraEntry {
+    name: string;
+    compressedSize: number;
+    uncompressedSize: number;
+    compressionMethod: number;
+    localHeaderOffset: number;
+}
+export interface AiraProtocolManifest {
+    protocol_id?: string | null;
+    protocol_version?: string | null;
+    protocol_name?: string | null;
+    entrypoint?: string;
+    archive_root?: string;
+    files?: string[];
+    file_hashes?: Record<string, string>;
+}
+export interface AiraRecordManifest {
+    path: string;
+    record_id?: string | null;
+    record_version?: string | number | null;
+    protocol_id?: string | null;
+    protocol_version?: string | null;
+    sha1?: string | null;
+    sha256?: string | null;
+    source_path?: string;
+    source_index?: number;
+    embedded_protocol_root?: string | null;
+}
+export interface AiralogyRecordPayload {
+    format?: string;
+    schema_version?: number;
+    airalogy_record_id?: string | null;
+    record_id?: string | null;
+    record_version?: number | null;
+    metadata?: Record<string, unknown> | null;
+    data?: {
+        var?: Record<string, unknown>;
+        step?: Record<string, unknown>;
+        check?: Record<string, unknown>;
+        quiz?: Record<string, unknown>;
+        [key: string]: unknown;
+    };
+    files?: Array<Record<string, unknown>>;
+    [key: string]: unknown;
+}
+export interface AiraBlobManifest {
+    blob_id: string;
+    archive_path: string;
+    sha256: string;
+    size?: number;
+}
+export interface AiraFileManifest {
+    file_id?: string | null;
+    source_uri?: string | null;
+    blob_id?: string | null;
+    filename?: string | null;
+    mime_type?: string | null;
+    size?: number | null;
+    record_path?: string | null;
+    field_path?: string | null;
+}
+export interface AiraManifest {
+    format: string;
+    version: number;
+    kind: AiraArchiveKind;
+    created_at?: string;
+    protocol?: AiraProtocolManifest;
+    records?: AiraRecordManifest[];
+    protocols?: AiraProtocolManifest[];
+    blobs?: AiraBlobManifest[];
+    files?: AiraFileManifest[];
+    [key: string]: unknown;
+}
+export interface AiraSummary {
+    format: string;
+    version: number;
+    kind: AiraArchiveKind;
+    createdAt?: string;
+    memberCount: number;
+    recordCount: number;
+    protocolCount: number;
+    blobCount: number;
+    fileCount: number;
+}
+export interface AiraValidationResult {
+    ok: boolean;
+    issues: string[];
+}
+export type AiraArchiveEntryData = string | Blob | ArrayBuffer | ArrayBufferView;
+export interface CreateProtocolAiraArchiveFile {
+    path: string;
+    data: AiraArchiveEntryData;
+}
+export interface CreateProtocolAiraArchiveOptions {
+    aimd: string;
+    protocol?: Pick<AiraProtocolManifest, 'protocol_id' | 'protocol_version' | 'protocol_name' | 'entrypoint'>;
+    files?: CreateProtocolAiraArchiveFile[];
+    createdAt?: string;
+}
+export declare function createProtocolAiraArchive(options: CreateProtocolAiraArchiveOptions): Promise<Uint8Array>;
+export declare class AiraArchive {
+    readonly bytes: Uint8Array;
+    readonly entries: AiraEntry[];
+    readonly manifest: AiraManifest;
+    private readonly entryMap;
+    private constructor();
+    static open(input: ArrayBuffer | Blob | Uint8Array): Promise<AiraArchive>;
+    has(path: string): boolean;
+    summary(): AiraSummary;
+    readBytes(path: string): Promise<Uint8Array>;
+    readText(path: string): Promise<string>;
+    readJson<T = unknown>(path: string): Promise<T>;
+    validate(): Promise<AiraValidationResult>;
+    private validateProtocol;
+    private validateProtocolList;
+    private validateRecords;
+    private validateBlobs;
+    private validateFileReferences;
+}
+export declare function openAiraArchive(input: ArrayBuffer | Blob | Uint8Array): Promise<AiraArchive>;
+export declare function readAiraArchiveSummary(input: ArrayBuffer | Blob | Uint8Array): Promise<AiraSummary>;
+export declare function prettyPrintJson(value: unknown): string;
+export declare function encodeUtf8(value: string): Uint8Array;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -1,83 +1,248 @@
-const b = "_airalogy_archive/manifest.json", g = "airalogy.archive", A = new TextDecoder("utf-8"), E = new TextEncoder(), R = /^[0-9a-f]{64}$/;
-function m(i, t) {
-  return i.getUint16(t, !0);
+const m = "_airalogy_archive/manifest.json", A = "airalogy.archive", B = "airalogy.record", Q = 1, E = new TextDecoder("utf-8"), w = new TextEncoder(), M = /^[0-9a-f]{64}$/, O = 0, L = 2048, j = 4294967295;
+function d(e, t) {
+  return e.getUint16(t, !0);
 }
-function p(i, t) {
-  return i.getUint32(t, !0);
+function p(e, t) {
+  return e.getUint32(t, !0);
 }
-function U(i) {
-  return A.decode(i);
+function H(e) {
+  return E.decode(e);
 }
-function v(i) {
-  return !i || i.startsWith("/") ? `Archive member '${i}' uses an absolute or empty path.` : i.split("/").some((t) => t === "..") ? `Archive member '${i}' escapes the archive root.` : null;
+function v(e) {
+  return !e || e.startsWith("/") ? `Archive member '${e}' uses an absolute or empty path.` : e.split("/").some((t) => t === "..") ? `Archive member '${e}' escapes the archive root.` : null;
 }
-function k(i) {
-  const t = Math.max(0, i.length - 65535 - 22);
-  for (let o = i.length - 22; o >= t; o -= 1)
-    if (i[o] === 80 && i[o + 1] === 75 && i[o + 2] === 5 && i[o + 3] === 6)
-      return o;
+function P(e, t) {
+  const n = e.replace(/\\/g, "/").split("/").filter((r) => r && r !== ".").join("/"), i = v(n);
+  if (i || e.startsWith("/") || e.replace(/\\/g, "/").split("/").some((r) => r === ".."))
+    throw new Error(i ?? `${t} '${e}' is not a safe relative archive path.`);
+  if (n === m || n.startsWith("_airalogy_archive/"))
+    throw new Error(`${t} '${e}' conflicts with Airalogy archive metadata.`);
+  return n;
+}
+function y(e) {
+  return !!e && typeof e == "object" && !Array.isArray(e);
+}
+function N(e, t) {
+  const n = [];
+  if (!y(e))
+    return [`${t} must be a JSON object.`];
+  e.format !== void 0 && e.format !== B && n.push(`${t} format must be '${B}' when present.`), e.schema_version !== void 0 && e.schema_version !== 1 && n.push(`${t} schema_version must be 1 when present.`), e.record_id !== void 0 && e.record_id !== null && (typeof e.record_id != "string" || e.record_id.length === 0) && n.push(`${t} record_id must be a non-empty string when present.`), e.airalogy_record_id !== void 0 && e.airalogy_record_id !== null && (typeof e.airalogy_record_id != "string" || e.airalogy_record_id.length === 0) && n.push(`${t} airalogy_record_id must be a non-empty string when present.`);
+  const i = e.record_version;
+  if (i != null && (typeof i != "number" || !Number.isInteger(i) || i < 1) && n.push(`${t} record_version must be a positive integer when present.`), e.metadata !== void 0 && e.metadata !== null && !y(e.metadata) && n.push(`${t} metadata must be an object when present.`), !y(e.data))
+    return n.push(`${t} data must be an object.`), n;
+  y(e.data.var) || n.push(`${t} data.var must be an object.`);
+  for (const r of ["step", "check", "quiz"]) {
+    const s = e.data[r];
+    s != null && !y(s) && n.push(`${t} data.${r} must be an object when present.`);
+  }
+  if (e.files !== void 0)
+    if (!Array.isArray(e.files))
+      n.push(`${t} files must be a list when present.`);
+    else
+      for (const [r, s] of e.files.entries()) {
+        if (!y(s)) {
+          n.push(`${t} files[${r + 1}] must be an object.`);
+          continue;
+        }
+        ["file_id", "source_uri", "blob_id"].some((o) => typeof s[o] == "string" && s[o]) || n.push(`${t} files[${r + 1}] must include file_id, source_uri, or blob_id.`);
+      }
+  return n;
+}
+function T(e) {
+  const t = Math.max(0, e.length - 65535 - 22);
+  for (let n = e.length - 22; n >= t; n -= 1)
+    if (e[n] === 80 && e[n + 1] === 75 && e[n + 2] === 5 && e[n + 3] === 6)
+      return n;
   throw new Error("Archive is not a valid zip file: EOCD not found.");
 }
-function D(i) {
-  const t = new DataView(i.buffer, i.byteOffset, i.byteLength), o = k(i), n = m(t, o + 10), s = p(t, o + 16), c = [];
-  let e = s;
-  for (let r = 0; r < n; r += 1) {
-    if (p(t, e) !== 33639248)
-      throw new Error(`Archive central directory is invalid at offset ${e}.`);
-    const a = m(t, e + 10), h = p(t, e + 20), l = p(t, e + 24), f = m(t, e + 28), d = m(t, e + 30), $ = m(t, e + 32), u = p(t, e + 42), w = e + 46, S = U(i.slice(w, w + f));
-    if (p(t, u) !== 67324752)
-      throw new Error(`Archive local header is invalid for '${S}'.`);
-    const B = m(t, u + 26), P = m(t, u + 28), x = u + 30 + B + P;
-    c.push({
-      name: S,
-      compressionMethod: a,
-      compressedSize: h,
-      uncompressedSize: l,
-      localHeaderOffset: u,
-      compressedDataStart: x
-    }), e = w + f + d + $;
+function C(e) {
+  const t = new DataView(e.buffer, e.byteOffset, e.byteLength), n = T(e), i = d(t, n + 10), r = p(t, n + 16), s = [];
+  let o = r;
+  for (let a = 0; a < i; a += 1) {
+    if (p(t, o) !== 33639248)
+      throw new Error(`Archive central directory is invalid at offset ${o}.`);
+    const c = d(t, o + 10), f = p(t, o + 20), h = p(t, o + 24), l = d(t, o + 28), u = d(t, o + 30), $ = d(t, o + 32), g = p(t, o + 42), S = o + 46, R = H(e.slice(S, S + l));
+    if (p(t, g) !== 67324752)
+      throw new Error(`Archive local header is invalid for '${R}'.`);
+    const D = d(t, g + 26), x = d(t, g + 28), I = g + 30 + D + x;
+    s.push({
+      name: R,
+      compressionMethod: c,
+      compressedSize: f,
+      uncompressedSize: h,
+      localHeaderOffset: g,
+      compressedDataStart: I
+    }), o = S + l + u + $;
   }
-  return c.filter((r) => !r.name.endsWith("/"));
+  return s.filter((a) => !a.name.endsWith("/"));
 }
-async function j(i) {
+async function k(e) {
   const t = globalThis.DecompressionStream;
   if (!t)
     throw new Error("This browser does not support DecompressionStream.");
-  const o = new Blob([i]).stream().pipeThrough(new t("deflate-raw")), n = await new Response(o).arrayBuffer();
-  return new Uint8Array(n);
+  const n = new Blob([e]).stream().pipeThrough(new t("deflate-raw")), i = await new Response(n).arrayBuffer();
+  return new Uint8Array(i);
+}
+async function U(e) {
+  const t = await crypto.subtle.digest("SHA-256", e);
+  return Array.from(new Uint8Array(t)).map((n) => n.toString(16).padStart(2, "0")).join("");
+}
+function z() {
+  const e = new Uint32Array(256);
+  for (let t = 0; t < 256; t += 1) {
+    let n = t;
+    for (let i = 0; i < 8; i += 1)
+      n = n & 1 ? 3988292384 ^ n >>> 1 : n >>> 1;
+    e[t] = n >>> 0;
+  }
+  return e;
+}
+const F = z();
+function V(e) {
+  let t = 4294967295;
+  for (const n of e)
+    t = F[(t ^ n) & 255] ^ t >>> 8;
+  return (t ^ 4294967295) >>> 0;
+}
+function Z(e) {
+  const t = e.reduce((r, s) => r + s.byteLength, 0), n = new Uint8Array(t);
+  let i = 0;
+  for (const r of e)
+    n.set(r, i), i += r.byteLength;
+  return n;
+}
+function J(e) {
+  const t = Math.max(1980, Math.min(2107, e.getFullYear())), n = e.getMonth() + 1, i = e.getDate(), r = e.getHours(), s = e.getMinutes(), o = Math.floor(e.getSeconds() / 2);
+  return {
+    time: r << 11 | s << 5 | o,
+    date: t - 1980 << 9 | n << 5 | i
+  };
+}
+function b(e, t) {
+  if (!Number.isInteger(e) || e < 0 || e > j)
+    throw new Error(`${t} exceeds the ZIP32 size limit.`);
+}
+function W(e, t) {
+  const n = w.encode(e.name);
+  b(e.bytes.byteLength, `Archive member '${e.name}'`);
+  const i = new Uint8Array(30 + n.byteLength), r = new DataView(i.buffer, i.byteOffset, i.byteLength);
+  return r.setUint32(0, 67324752, !0), r.setUint16(4, 20, !0), r.setUint16(6, L, !0), r.setUint16(8, O, !0), r.setUint16(10, t.time, !0), r.setUint16(12, t.date, !0), r.setUint32(14, e.crc32, !0), r.setUint32(18, e.bytes.byteLength, !0), r.setUint32(22, e.bytes.byteLength, !0), r.setUint16(26, n.byteLength, !0), r.setUint16(28, 0, !0), i.set(n, 30), i;
+}
+function G(e, t) {
+  const n = w.encode(e.name), i = new Uint8Array(46 + n.byteLength), r = new DataView(i.buffer, i.byteOffset, i.byteLength);
+  return r.setUint32(0, 33639248, !0), r.setUint16(4, 20, !0), r.setUint16(6, 20, !0), r.setUint16(8, L, !0), r.setUint16(10, O, !0), r.setUint16(12, t.time, !0), r.setUint16(14, t.date, !0), r.setUint32(16, e.crc32, !0), r.setUint32(20, e.bytes.byteLength, !0), r.setUint32(24, e.bytes.byteLength, !0), r.setUint16(28, n.byteLength, !0), r.setUint16(30, 0, !0), r.setUint16(32, 0, !0), r.setUint16(34, 0, !0), r.setUint16(36, 0, !0), r.setUint32(38, 0, !0), r.setUint32(42, e.localHeaderOffset, !0), i.set(n, 46), i;
+}
+function Y(e, t, n) {
+  if (b(e, "Archive entry count"), b(t, "Central directory"), b(n, "Central directory offset"), e > 65535)
+    throw new Error("Archive entry count exceeds the ZIP32 entry limit.");
+  const i = new Uint8Array(22), r = new DataView(i.buffer);
+  return r.setUint32(0, 101010256, !0), r.setUint16(4, 0, !0), r.setUint16(6, 0, !0), r.setUint16(8, e, !0), r.setUint16(10, e, !0), r.setUint32(12, t, !0), r.setUint32(16, n, !0), r.setUint16(20, 0, !0), i;
+}
+function q(e, t = /* @__PURE__ */ new Date()) {
+  const n = J(t), i = [], r = [], s = [];
+  let o = 0;
+  for (const f of e) {
+    const h = {
+      ...f,
+      crc32: V(f.bytes),
+      localHeaderOffset: o
+    }, l = W(h, n);
+    r.push(l, h.bytes), o += l.byteLength + h.bytes.byteLength, b(o, "Archive size"), i.push(h);
+  }
+  const a = o;
+  for (const f of i) {
+    const h = G(f, n);
+    s.push(h), o += h.byteLength, b(o, "Archive size");
+  }
+  const c = o - a;
+  return Z([
+    ...r,
+    ...s,
+    Y(i.length, c, a)
+  ]);
+}
+async function X(e) {
+  if (typeof e == "string")
+    return w.encode(e);
+  if (typeof Blob < "u" && e instanceof Blob)
+    return new Uint8Array(await e.arrayBuffer());
+  if (e instanceof ArrayBuffer)
+    return new Uint8Array(e);
+  if (ArrayBuffer.isView(e))
+    return new Uint8Array(e.buffer, e.byteOffset, e.byteLength);
+  throw new Error("Archive entry data must be a string, Blob, ArrayBuffer, or ArrayBufferView.");
 }
-async function _(i) {
-  const t = await crypto.subtle.digest("SHA-256", i);
-  return Array.from(new Uint8Array(t)).map((o) => o.toString(16).padStart(2, "0")).join("");
+function K(e) {
+  for (const t of e.split(/\r?\n/)) {
+    const n = t.trim();
+    if (n.startsWith("# "))
+      return n.slice(2).trim() || null;
+  }
+  return null;
+}
+async function tt(e) {
+  const t = P(e.protocol?.entrypoint ?? "protocol.aimd", "Protocol entrypoint"), n = /* @__PURE__ */ new Map();
+  n.set(t, w.encode(e.aimd));
+  for (const a of e.files ?? []) {
+    const c = P(a.path, "Protocol file");
+    if (c === t || n.has(c))
+      throw new Error(`Protocol archive contains duplicate file path '${c}'.`);
+    n.set(c, await X(a.data));
+  }
+  const i = Array.from(n.keys()), r = {};
+  for (const [a, c] of n)
+    r[a] = await U(c);
+  const s = {
+    format: A,
+    version: 1,
+    kind: "protocol",
+    created_at: e.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    protocol: {
+      protocol_id: e.protocol?.protocol_id ?? null,
+      protocol_version: e.protocol?.protocol_version ?? null,
+      protocol_name: e.protocol?.protocol_name ?? K(e.aimd) ?? null,
+      entrypoint: t,
+      files: i,
+      file_hashes: r
+    }
+  }, o = [
+    {
+      name: m,
+      bytes: w.encode(`${JSON.stringify(s, null, 2)}
+`)
+    },
+    ...i.map((a) => ({ name: a, bytes: n.get(a) }))
+  ];
+  return q(o);
 }
-class y {
+class _ {
   bytes;
   entries;
   manifest;
   entryMap;
-  constructor(t, o, n) {
-    this.bytes = t, this.entries = o.map(({ compressedDataStart: s, ...c }) => c), this.entryMap = new Map(o.map((s) => [s.name, s])), this.manifest = n;
+  constructor(t, n, i) {
+    this.bytes = t, this.entries = n.map(({ compressedDataStart: r, ...s }) => s), this.entryMap = new Map(n.map((r) => [r.name, r])), this.manifest = i;
   }
   static async open(t) {
-    const o = t instanceof Uint8Array ? t : t instanceof Blob ? new Uint8Array(await t.arrayBuffer()) : new Uint8Array(t), n = D(o);
-    if (!n.find((r) => r.name === b))
-      throw new Error(`Archive does not contain '${b}'.`);
-    const e = await new y(o, n, {
-      format: g,
+    const n = t instanceof Uint8Array ? t : t instanceof Blob ? new Uint8Array(await t.arrayBuffer()) : new Uint8Array(t), i = C(n);
+    if (!i.find((a) => a.name === m))
+      throw new Error(`Archive does not contain '${m}'.`);
+    const o = await new _(n, i, {
+      format: A,
       version: 0,
       kind: "records"
-    }).readJson(b);
-    if (e.format !== g)
-      throw new Error(`Unsupported archive format '${String(e.format)}'.`);
-    if (e.kind !== "protocol" && e.kind !== "protocols" && e.kind !== "records")
-      throw new Error(`Unsupported archive kind '${String(e.kind)}'.`);
-    return new y(o, n, e);
+    }).readJson(m);
+    if (o.format !== A)
+      throw new Error(`Unsupported archive format '${String(o.format)}'.`);
+    if (o.kind !== "protocol" && o.kind !== "protocols" && o.kind !== "records")
+      throw new Error(`Unsupported archive kind '${String(o.kind)}'.`);
+    return new _(n, i, o);
   }
   has(t) {
     return this.entryMap.has(t);
   }
   summary() {
-    const t = Array.isArray(this.manifest.records) ? this.manifest.records.length : 0, o = this.manifest.kind === "protocol" ? 1 : Array.isArray(this.manifest.protocols) ? this.manifest.protocols.length : 0, n = Array.isArray(this.manifest.blobs) ? this.manifest.blobs.length : 0, s = Array.isArray(this.manifest.files) ? this.manifest.files.length : 0;
+    const t = Array.isArray(this.manifest.records) ? this.manifest.records.length : 0, n = this.manifest.kind === "protocol" ? 1 : Array.isArray(this.manifest.protocols) ? this.manifest.protocols.length : 0, i = Array.isArray(this.manifest.blobs) ? this.manifest.blobs.length : 0, r = Array.isArray(this.manifest.files) ? this.manifest.files.length : 0;
     return {
       format: this.manifest.format,
       version: this.manifest.version,
@@ -85,207 +250,210 @@ class y {
       createdAt: this.manifest.created_at,
       memberCount: this.entries.length,
       recordCount: t,
-      protocolCount: o,
-      blobCount: n,
-      fileCount: s
+      protocolCount: n,
+      blobCount: i,
+      fileCount: r
     };
   }
   async readBytes(t) {
-    const o = this.entryMap.get(t);
-    if (!o)
+    const n = this.entryMap.get(t);
+    if (!n)
       throw new Error(`Archive member '${t}' not found.`);
-    const n = this.bytes.slice(
-      o.compressedDataStart,
-      o.compressedDataStart + o.compressedSize
+    const i = this.bytes.slice(
+      n.compressedDataStart,
+      n.compressedDataStart + n.compressedSize
     );
-    if (o.compressionMethod === 0)
-      return n;
-    if (o.compressionMethod === 8)
-      return j(n);
-    throw new Error(`Archive member '${t}' uses unsupported compression method ${o.compressionMethod}.`);
+    if (n.compressionMethod === 0)
+      return i;
+    if (n.compressionMethod === 8)
+      return k(i);
+    throw new Error(`Archive member '${t}' uses unsupported compression method ${n.compressionMethod}.`);
   }
   async readText(t) {
-    return A.decode(await this.readBytes(t));
+    return E.decode(await this.readBytes(t));
   }
   async readJson(t) {
     return JSON.parse(await this.readText(t));
   }
   async validate() {
-    const t = [], o = new Set(this.entries.map((n) => n.name));
-    for (const n of this.entries) {
-      const s = v(n.name);
-      s && t.push(s);
+    const t = [], n = new Set(this.entries.map((i) => i.name));
+    for (const i of this.entries) {
+      const r = v(i.name);
+      r && t.push(r);
     }
-    return o.has(b) || t.push(`Archive is missing '${b}'.`), this.manifest.format !== g && t.push(`Unsupported archive format '${String(this.manifest.format)}'.`), this.manifest.version !== 1 && t.push(`Unsupported archive version '${String(this.manifest.version)}'.`), this.manifest.kind === "protocol" ? await this.validateProtocol(this.manifest.protocol, "", t) : this.manifest.kind === "protocols" ? await this.validateProtocolList(this.manifest.protocols, t, !0) : this.manifest.kind === "records" ? await this.validateRecords(t) : t.push(`Unsupported archive kind '${String(this.manifest.kind)}'.`), { ok: t.length === 0, issues: t };
+    return n.has(m) || t.push(`Archive is missing '${m}'.`), this.manifest.format !== A && t.push(`Unsupported archive format '${String(this.manifest.format)}'.`), this.manifest.version !== 1 && t.push(`Unsupported archive version '${String(this.manifest.version)}'.`), this.manifest.kind === "protocol" ? await this.validateProtocol(this.manifest.protocol, "", t) : this.manifest.kind === "protocols" ? await this.validateProtocolList(this.manifest.protocols, t, !0) : this.manifest.kind === "records" ? await this.validateRecords(t) : t.push(`Unsupported archive kind '${String(this.manifest.kind)}'.`), { ok: t.length === 0, issues: t };
   }
-  async validateProtocol(t, o, n) {
+  async validateProtocol(t, n, i) {
     if (!t || typeof t != "object") {
-      n.push("Protocol manifest entry must be an object.");
+      i.push("Protocol manifest entry must be an object.");
       return;
     }
-    const s = t.entrypoint || "protocol.aimd", c = `${o}${s}`;
-    this.has(c) || n.push(`Protocol entrypoint '${c}' is missing.`);
-    const e = Array.isArray(t.files) ? t.files : [], r = t.file_hashes && typeof t.file_hashes == "object" ? t.file_hashes : {};
-    for (const a of e) {
-      const h = `${o}${a}`, l = v(h);
-      if (l) {
-        n.push(l);
+    const r = t.entrypoint || "protocol.aimd", s = `${n}${r}`;
+    this.has(s) || i.push(`Protocol entrypoint '${s}' is missing.`);
+    const o = Array.isArray(t.files) ? t.files : [], a = t.file_hashes && typeof t.file_hashes == "object" ? t.file_hashes : {};
+    for (const c of o) {
+      const f = `${n}${c}`, h = v(f);
+      if (h) {
+        i.push(h);
         continue;
       }
-      if (!this.has(h)) {
-        n.push(`Protocol file '${h}' is missing.`);
+      if (!this.has(f)) {
+        i.push(`Protocol file '${f}' is missing.`);
         continue;
       }
-      const f = r[a];
-      if (f) {
-        const d = await _(await this.readBytes(h));
-        d !== f && n.push(`Protocol file '${h}' sha256 mismatch: expected ${f}, got ${d}.`);
+      const l = a[c];
+      if (l) {
+        const u = await U(await this.readBytes(f));
+        u !== l && i.push(`Protocol file '${f}' sha256 mismatch: expected ${l}, got ${u}.`);
       }
     }
   }
-  async validateProtocolList(t, o, n = !1) {
-    const s = /* @__PURE__ */ new Set();
+  async validateProtocolList(t, n, i = !1) {
+    const r = /* @__PURE__ */ new Set();
     if (!Array.isArray(t))
-      return o.push("Protocols manifest field must be a list."), s;
-    n && t.length === 0 && o.push("Protocols manifest field must include at least one protocol.");
-    for (const [c, e] of t.entries()) {
-      if (!e || typeof e != "object") {
-        o.push(`Protocol manifest entry #${c + 1} must be an object.`);
+      return n.push("Protocols manifest field must be a list."), r;
+    i && t.length === 0 && n.push("Protocols manifest field must include at least one protocol.");
+    for (const [s, o] of t.entries()) {
+      if (!o || typeof o != "object") {
+        n.push(`Protocol manifest entry #${s + 1} must be an object.`);
         continue;
       }
-      if (!e.archive_root) {
-        o.push(`Protocol manifest entry #${c + 1} is missing archive_root.`);
+      if (!o.archive_root) {
+        n.push(`Protocol manifest entry #${s + 1} is missing archive_root.`);
         continue;
       }
-      if (s.has(e.archive_root)) {
-        o.push(`Protocol manifest entry #${c + 1} uses duplicate archive_root '${e.archive_root}'.`);
+      if (r.has(o.archive_root)) {
+        n.push(`Protocol manifest entry #${s + 1} uses duplicate archive_root '${o.archive_root}'.`);
         continue;
       }
-      s.add(e.archive_root), await this.validateProtocol(e, `${e.archive_root.replace(/\/+$/, "")}/`, o);
+      r.add(o.archive_root), await this.validateProtocol(o, `${o.archive_root.replace(/\/+$/, "")}/`, n);
     }
-    return s;
+    return r;
   }
   async validateRecords(t) {
-    const o = Array.isArray(this.manifest.records) ? this.manifest.records : [], n = await this.validateProtocolList(this.manifest.protocols, t), s = /* @__PURE__ */ new Set();
-    for (const [e, r] of o.entries()) {
-      if (!r || typeof r != "object") {
-        t.push(`Record manifest entry #${e + 1} must be an object.`);
+    const n = Array.isArray(this.manifest.records) ? this.manifest.records : [], i = await this.validateProtocolList(this.manifest.protocols, t), r = /* @__PURE__ */ new Set();
+    for (const [o, a] of n.entries()) {
+      if (!a || typeof a != "object") {
+        t.push(`Record manifest entry #${o + 1} must be an object.`);
         continue;
       }
-      const a = r.path;
-      if (!a) {
-        t.push(`Record manifest entry #${e + 1} is missing a path.`);
+      const c = a.path;
+      if (!c) {
+        t.push(`Record manifest entry #${o + 1} is missing a path.`);
         continue;
       }
-      const h = v(a);
-      if (h) {
-        t.push(h);
+      const f = v(c);
+      if (f) {
+        t.push(f);
         continue;
       }
-      if (!this.has(a)) {
-        t.push(`Record file '${a}' is missing.`);
+      if (!this.has(c)) {
+        t.push(`Record file '${c}' is missing.`);
         continue;
       }
-      s.add(a);
-      let l;
+      r.add(c);
+      let h, l;
       try {
-        l = await this.readBytes(a), JSON.parse(A.decode(l));
+        h = await this.readBytes(c), l = JSON.parse(E.decode(h));
       } catch {
-        t.push(`Record file '${a}' is not valid UTF-8 JSON.`);
+        t.push(`Record file '${c}' is not valid UTF-8 JSON.`);
         continue;
       }
-      if (r.sha256) {
-        const f = await _(l);
-        f !== r.sha256 && t.push(`Record file '${a}' sha256 mismatch: expected ${r.sha256}, got ${f}.`);
+      if (t.push(...N(l, `Record file '${c}'`)), a.sha256) {
+        const u = await U(h);
+        u !== a.sha256 && t.push(`Record file '${c}' sha256 mismatch: expected ${a.sha256}, got ${u}.`);
       }
-      r.embedded_protocol_root && !n.has(r.embedded_protocol_root) && t.push(`Record file '${a}' references missing embedded protocol root '${r.embedded_protocol_root}'.`);
+      a.embedded_protocol_root && !i.has(a.embedded_protocol_root) && t.push(`Record file '${c}' references missing embedded protocol root '${a.embedded_protocol_root}'.`);
     }
-    const c = await this.validateBlobs(t);
-    this.validateFileReferences(t, c, s);
+    const s = await this.validateBlobs(t);
+    this.validateFileReferences(t, s, r);
   }
   async validateBlobs(t) {
-    const o = /* @__PURE__ */ new Set(), n = this.manifest.blobs;
-    if (n === void 0)
-      return o;
-    if (!Array.isArray(n))
-      return t.push("Blobs manifest field must be a list."), o;
-    const s = /* @__PURE__ */ new Set();
-    for (const [c, e] of n.entries()) {
-      if (!e || typeof e != "object") {
-        t.push(`Blob manifest entry #${c + 1} must be an object.`);
+    const n = /* @__PURE__ */ new Set(), i = this.manifest.blobs;
+    if (i === void 0)
+      return n;
+    if (!Array.isArray(i))
+      return t.push("Blobs manifest field must be a list."), n;
+    const r = /* @__PURE__ */ new Set();
+    for (const [s, o] of i.entries()) {
+      if (!o || typeof o != "object") {
+        t.push(`Blob manifest entry #${s + 1} must be an object.`);
         continue;
       }
-      const r = e.blob_id, a = e.archive_path, h = e.sha256;
-      if (!r) {
-        t.push(`Blob manifest entry #${c + 1} is missing blob_id.`);
+      const a = o.blob_id, c = o.archive_path, f = o.sha256;
+      if (!a) {
+        t.push(`Blob manifest entry #${s + 1} is missing blob_id.`);
         continue;
       }
-      if (o.has(r)) {
-        t.push(`Blob manifest entry #${c + 1} uses duplicate blob_id '${r}'.`);
+      if (n.has(a)) {
+        t.push(`Blob manifest entry #${s + 1} uses duplicate blob_id '${a}'.`);
         continue;
       }
-      if (o.add(r), !h || !R.test(h)) {
-        t.push(`Blob '${r}' must include a valid sha256 hash.`);
+      if (n.add(a), !f || !M.test(f)) {
+        t.push(`Blob '${a}' must include a valid sha256 hash.`);
         continue;
       }
-      const l = `sha256:${h}`;
-      if (r !== l && t.push(`Blob '${r}' does not match sha256-derived id '${l}'.`), !a) {
-        t.push(`Blob '${r}' is missing archive_path.`);
+      const h = `sha256:${f}`;
+      if (a !== h && t.push(`Blob '${a}' does not match sha256-derived id '${h}'.`), !c) {
+        t.push(`Blob '${a}' is missing archive_path.`);
         continue;
       }
-      const f = v(a);
-      if (f) {
-        t.push(f);
+      const l = v(c);
+      if (l) {
+        t.push(l);
         continue;
       }
-      if (a.startsWith("blobs/sha256/") || t.push(`Blob '${r}' archive_path must be under 'blobs/sha256/'.`), s.has(a)) {
-        t.push(`Blob '${r}' uses duplicate archive_path '${a}'.`);
+      if (c.startsWith("blobs/sha256/") || t.push(`Blob '${a}' archive_path must be under 'blobs/sha256/'.`), r.has(c)) {
+        t.push(`Blob '${a}' uses duplicate archive_path '${c}'.`);
         continue;
       }
-      if (s.add(a), !this.has(a)) {
-        t.push(`Blob file '${a}' is missing.`);
+      if (r.add(c), !this.has(c)) {
+        t.push(`Blob file '${c}' is missing.`);
         continue;
       }
-      const d = await this.readBytes(a), $ = await _(d);
-      $ !== h && t.push(`Blob file '${a}' sha256 mismatch: expected ${h}, got ${$}.`), typeof e.size == "number" && e.size !== d.byteLength ? t.push(`Blob file '${a}' size mismatch: expected ${e.size}, got ${d.byteLength}.`) : e.size !== void 0 && typeof e.size != "number" && t.push(`Blob '${r}' size must be a number when present.`);
+      const u = await this.readBytes(c), $ = await U(u);
+      $ !== f && t.push(`Blob file '${c}' sha256 mismatch: expected ${f}, got ${$}.`), typeof o.size == "number" && o.size !== u.byteLength ? t.push(`Blob file '${c}' size mismatch: expected ${o.size}, got ${u.byteLength}.`) : o.size !== void 0 && typeof o.size != "number" && t.push(`Blob '${a}' size must be a number when present.`);
     }
-    return o;
+    return n;
   }
-  validateFileReferences(t, o, n) {
-    const s = this.manifest.files;
-    if (s !== void 0) {
-      if (!Array.isArray(s)) {
+  validateFileReferences(t, n, i) {
+    const r = this.manifest.files;
+    if (r !== void 0) {
+      if (!Array.isArray(r)) {
         t.push("Files manifest field must be a list.");
         return;
       }
-      for (const [c, e] of s.entries()) {
-        if (!e || typeof e != "object") {
-          t.push(`File manifest entry #${c + 1} must be an object.`);
+      for (const [s, o] of r.entries()) {
+        if (!o || typeof o != "object") {
+          t.push(`File manifest entry #${s + 1} must be an object.`);
           continue;
         }
-        !e.file_id && !e.source_uri && !e.blob_id && t.push(`File manifest entry #${c + 1} must include file_id, source_uri, or blob_id.`), e.blob_id && !o.has(e.blob_id) && t.push(`File manifest entry #${c + 1} references missing blob_id '${e.blob_id}'.`), e.record_path && !n.has(e.record_path) && t.push(`File manifest entry #${c + 1} references missing record_path '${e.record_path}'.`), e.field_path !== void 0 && typeof e.field_path != "string" && t.push(`File manifest entry #${c + 1} field_path must be a string.`);
+        !o.file_id && !o.source_uri && !o.blob_id && t.push(`File manifest entry #${s + 1} must include file_id, source_uri, or blob_id.`), o.blob_id && !n.has(o.blob_id) && t.push(`File manifest entry #${s + 1} references missing blob_id '${o.blob_id}'.`), o.record_path && !i.has(o.record_path) && t.push(`File manifest entry #${s + 1} references missing record_path '${o.record_path}'.`), o.field_path !== void 0 && typeof o.field_path != "string" && t.push(`File manifest entry #${s + 1} field_path must be a string.`);
       }
     }
   }
 }
-async function M(i) {
-  return y.open(i);
+async function et(e) {
+  return _.open(e);
 }
-async function O(i) {
-  return (await y.open(i)).summary();
+async function nt(e) {
+  return (await _.open(e)).summary();
 }
-function z(i) {
-  return JSON.stringify(i, null, 2);
+function rt(e) {
+  return JSON.stringify(e, null, 2);
 }
-function F(i) {
-  return E.encode(i);
+function it(e) {
+  return w.encode(e);
 }
 export {
-  g as AIRA_ARCHIVE_FORMAT,
-  b as AIRA_MANIFEST_PATH,
-  y as AiraArchive,
-  F as encodeUtf8,
-  M as openAiraArchive,
-  z as prettyPrintJson,
-  O as readAiraArchiveSummary
+  B as AIRALOGY_RECORD_FORMAT,
+  Q as AIRALOGY_RECORD_SCHEMA_VERSION,
+  A as AIRA_ARCHIVE_FORMAT,
+  m as AIRA_MANIFEST_PATH,
+  _ as AiraArchive,
+  tt as createProtocolAiraArchive,
+  it as encodeUtf8,
+  et as openAiraArchive,
+  rt as prettyPrintJson,
+  nt as readAiraArchiveSummary
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@airalogy/aira-core",
   "type": "module",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Core parser and validator for Airalogy .aira archives",
   "license": "Apache-2.0",
   "repository": {

package/src/index.ts

@@ -1,5 +1,7 @@
 export const AIRA_MANIFEST_PATH = '_airalogy_archive/manifest.json'
 export const AIRA_ARCHIVE_FORMAT = 'airalogy.archive'
+export const AIRALOGY_RECORD_FORMAT = 'airalogy.record'
+export const AIRALOGY_RECORD_SCHEMA_VERSION = 1
 
 export type AiraArchiveKind = 'protocol' | 'protocols' | 'records'
 
@@ -34,6 +36,24 @@ export interface AiraRecordManifest {
   embedded_protocol_root?: string | null
 }
 
+export interface AiralogyRecordPayload {
+  format?: string
+  schema_version?: number
+  airalogy_record_id?: string | null
+  record_id?: string | null
+  record_version?: number | null
+  metadata?: Record<string, unknown> | null
+  data?: {
+    var?: Record<string, unknown>
+    step?: Record<string, unknown>
+    check?: Record<string, unknown>
+    quiz?: Record<string, unknown>
+    [key: string]: unknown
+  }
+  files?: Array<Record<string, unknown>>
+  [key: string]: unknown
+}
+
 export interface AiraBlobManifest {
   blob_id: string
   archive_path: string
@@ -82,13 +102,40 @@ export interface AiraValidationResult {
   issues: string[]
 }
 
+export type AiraArchiveEntryData = string | Blob | ArrayBuffer | ArrayBufferView
+
+export interface CreateProtocolAiraArchiveFile {
+  path: string
+  data: AiraArchiveEntryData
+}
+
+export interface CreateProtocolAiraArchiveOptions {
+  aimd: string
+  protocol?: Pick<AiraProtocolManifest, 'protocol_id' | 'protocol_version' | 'protocol_name' | 'entrypoint'>
+  files?: CreateProtocolAiraArchiveFile[]
+  createdAt?: string
+}
+
 type ZipEntryInternal = AiraEntry & {
   compressedDataStart: number
 }
 
+type ZipEntryPayload = {
+  name: string
+  bytes: Uint8Array
+}
+
+type ZipEntryPrepared = ZipEntryPayload & {
+  crc32: number
+  localHeaderOffset: number
+}
+
 const textDecoder = new TextDecoder('utf-8')
 const textEncoder = new TextEncoder()
 const sha256Pattern = /^[0-9a-f]{64}$/
+const ZIP_STORED_METHOD = 0
+const ZIP_UTF8_FLAG = 0x0800
+const ZIP_UINT32_MAX = 0xffffffff
 
 function getUint16(view: DataView, offset: number): number {
   return view.getUint16(offset, true)
@@ -112,6 +159,104 @@ function validateMemberPath(name: string): string | null {
   return null
 }
 
+function normalizeArchiveMemberPath(path: string, label: string): string {
+  const normalized = path
+    .replace(/\\/g, '/')
+    .split('/')
+    .filter(part => part && part !== '.')
+    .join('/')
+  const issue = validateMemberPath(normalized)
+  if (issue || path.startsWith('/') || path.replace(/\\/g, '/').split('/').some(part => part === '..')) {
+    throw new Error(issue ?? `${label} '${path}' is not a safe relative archive path.`)
+  }
+  if (normalized === AIRA_MANIFEST_PATH || normalized.startsWith('_airalogy_archive/')) {
+    throw new Error(`${label} '${path}' conflicts with Airalogy archive metadata.`)
+  }
+  return normalized
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value)
+}
+
+function validateRecordPayload(record: unknown, label: string): string[] {
+  const issues: string[] = []
+  if (!isPlainObject(record)) {
+    return [`${label} must be a JSON object.`]
+  }
+
+  if (record.format !== undefined && record.format !== AIRALOGY_RECORD_FORMAT) {
+    issues.push(`${label} format must be '${AIRALOGY_RECORD_FORMAT}' when present.`)
+  }
+  if (
+    record.schema_version !== undefined
+    && record.schema_version !== AIRALOGY_RECORD_SCHEMA_VERSION
+  ) {
+    issues.push(`${label} schema_version must be ${AIRALOGY_RECORD_SCHEMA_VERSION} when present.`)
+  }
+  if (
+    record.record_id !== undefined
+    && record.record_id !== null
+    && (typeof record.record_id !== 'string' || record.record_id.length === 0)
+  ) {
+    issues.push(`${label} record_id must be a non-empty string when present.`)
+  }
+  if (
+    record.airalogy_record_id !== undefined
+    && record.airalogy_record_id !== null
+    && (typeof record.airalogy_record_id !== 'string' || record.airalogy_record_id.length === 0)
+  ) {
+    issues.push(`${label} airalogy_record_id must be a non-empty string when present.`)
+  }
+  const recordVersion = record.record_version
+  if (
+    recordVersion !== undefined
+    && recordVersion !== null
+    && (typeof recordVersion !== 'number' || !Number.isInteger(recordVersion) || recordVersion < 1)
+  ) {
+    issues.push(`${label} record_version must be a positive integer when present.`)
+  }
+  if (
+    record.metadata !== undefined
+    && record.metadata !== null
+    && !isPlainObject(record.metadata)
+  ) {
+    issues.push(`${label} metadata must be an object when present.`)
+  }
+
+  if (!isPlainObject(record.data)) {
+    issues.push(`${label} data must be an object.`)
+    return issues
+  }
+  if (!isPlainObject(record.data.var)) {
+    issues.push(`${label} data.var must be an object.`)
+  }
+  for (const section of ['step', 'check', 'quiz']) {
+    const value = record.data[section]
+    if (value !== undefined && value !== null && !isPlainObject(value)) {
+      issues.push(`${label} data.${section} must be an object when present.`)
+    }
+  }
+
+  if (record.files !== undefined) {
+    if (!Array.isArray(record.files)) {
+      issues.push(`${label} files must be a list when present.`)
+    }
+    else {
+      for (const [index, fileRef] of record.files.entries()) {
+        if (!isPlainObject(fileRef)) {
+          issues.push(`${label} files[${index + 1}] must be an object.`)
+          continue
+        }
+        if (!['file_id', 'source_uri', 'blob_id'].some(key => typeof fileRef[key] === 'string' && fileRef[key])) {
+          issues.push(`${label} files[${index + 1}] must include file_id, source_uri, or blob_id.`)
+        }
+      }
+    }
+  }
+  return issues
+}
+
 function findEndOfCentralDirectory(bytes: Uint8Array): number {
   const minOffset = Math.max(0, bytes.length - 0xffff - 22)
   for (let offset = bytes.length - 22; offset >= minOffset; offset -= 1) {
@@ -189,6 +334,229 @@ async function sha256Hex(bytes: Uint8Array): Promise<string> {
     .join('')
 }
 
+function makeCrc32Table(): Uint32Array {
+  const table = new Uint32Array(256)
+  for (let index = 0; index < 256; index += 1) {
+    let value = index
+    for (let bit = 0; bit < 8; bit += 1) {
+      value = value & 1 ? 0xedb88320 ^ (value >>> 1) : value >>> 1
+    }
+    table[index] = value >>> 0
+  }
+  return table
+}
+
+const crc32Table = makeCrc32Table()
+
+function crc32(bytes: Uint8Array): number {
+  let crc = 0xffffffff
+  for (const byte of bytes) {
+    crc = crc32Table[(crc ^ byte) & 0xff] ^ (crc >>> 8)
+  }
+  return (crc ^ 0xffffffff) >>> 0
+}
+
+function concatBytes(parts: Uint8Array[]): Uint8Array {
+  const totalLength = parts.reduce((sum, part) => sum + part.byteLength, 0)
+  const output = new Uint8Array(totalLength)
+  let offset = 0
+  for (const part of parts) {
+    output.set(part, offset)
+    offset += part.byteLength
+  }
+  return output
+}
+
+function dateToDosTimeAndDate(date: Date): { time: number; date: number } {
+  const year = Math.max(1980, Math.min(2107, date.getFullYear()))
+  const month = date.getMonth() + 1
+  const day = date.getDate()
+  const hours = date.getHours()
+  const minutes = date.getMinutes()
+  const seconds = Math.floor(date.getSeconds() / 2)
+  return {
+    time: (hours << 11) | (minutes << 5) | seconds,
+    date: ((year - 1980) << 9) | (month << 5) | day,
+  }
+}
+
+function assertZipUint32(value: number, label: string): void {
+  if (!Number.isInteger(value) || value < 0 || value > ZIP_UINT32_MAX) {
+    throw new Error(`${label} exceeds the ZIP32 size limit.`)
+  }
+}
+
+function writeZipLocalHeader(entry: ZipEntryPrepared, dos: { time: number; date: number }): Uint8Array {
+  const nameBytes = textEncoder.encode(entry.name)
+  assertZipUint32(entry.bytes.byteLength, `Archive member '${entry.name}'`)
+  const header = new Uint8Array(30 + nameBytes.byteLength)
+  const view = new DataView(header.buffer, header.byteOffset, header.byteLength)
+  view.setUint32(0, 0x04034b50, true)
+  view.setUint16(4, 20, true)
+  view.setUint16(6, ZIP_UTF8_FLAG, true)
+  view.setUint16(8, ZIP_STORED_METHOD, true)
+  view.setUint16(10, dos.time, true)
+  view.setUint16(12, dos.date, true)
+  view.setUint32(14, entry.crc32, true)
+  view.setUint32(18, entry.bytes.byteLength, true)
+  view.setUint32(22, entry.bytes.byteLength, true)
+  view.setUint16(26, nameBytes.byteLength, true)
+  view.setUint16(28, 0, true)
+  header.set(nameBytes, 30)
+  return header
+}
+
+function writeZipCentralDirectoryEntry(entry: ZipEntryPrepared, dos: { time: number; date: number }): Uint8Array {
+  const nameBytes = textEncoder.encode(entry.name)
+  const header = new Uint8Array(46 + nameBytes.byteLength)
+  const view = new DataView(header.buffer, header.byteOffset, header.byteLength)
+  view.setUint32(0, 0x02014b50, true)
+  view.setUint16(4, 20, true)
+  view.setUint16(6, 20, true)
+  view.setUint16(8, ZIP_UTF8_FLAG, true)
+  view.setUint16(10, ZIP_STORED_METHOD, true)
+  view.setUint16(12, dos.time, true)
+  view.setUint16(14, dos.date, true)
+  view.setUint32(16, entry.crc32, true)
+  view.setUint32(20, entry.bytes.byteLength, true)
+  view.setUint32(24, entry.bytes.byteLength, true)
+  view.setUint16(28, nameBytes.byteLength, true)
+  view.setUint16(30, 0, true)
+  view.setUint16(32, 0, true)
+  view.setUint16(34, 0, true)
+  view.setUint16(36, 0, true)
+  view.setUint32(38, 0, true)
+  view.setUint32(42, entry.localHeaderOffset, true)
+  header.set(nameBytes, 46)
+  return header
+}
+
+function writeZipEndOfCentralDirectory(entryCount: number, centralDirectorySize: number, centralDirectoryOffset: number): Uint8Array {
+  assertZipUint32(entryCount, 'Archive entry count')
+  assertZipUint32(centralDirectorySize, 'Central directory')
+  assertZipUint32(centralDirectoryOffset, 'Central directory offset')
+  if (entryCount > 0xffff) {
+    throw new Error('Archive entry count exceeds the ZIP32 entry limit.')
+  }
+  const end = new Uint8Array(22)
+  const view = new DataView(end.buffer)
+  view.setUint32(0, 0x06054b50, true)
+  view.setUint16(4, 0, true)
+  view.setUint16(6, 0, true)
+  view.setUint16(8, entryCount, true)
+  view.setUint16(10, entryCount, true)
+  view.setUint32(12, centralDirectorySize, true)
+  view.setUint32(16, centralDirectoryOffset, true)
+  view.setUint16(20, 0, true)
+  return end
+}
+
+function createStoredZip(entries: ZipEntryPayload[], date = new Date()): Uint8Array {
+  const dos = dateToDosTimeAndDate(date)
+  const preparedEntries: ZipEntryPrepared[] = []
+  const localParts: Uint8Array[] = []
+  const centralParts: Uint8Array[] = []
+  let offset = 0
+
+  for (const entry of entries) {
+    const prepared: ZipEntryPrepared = {
+      ...entry,
+      crc32: crc32(entry.bytes),
+      localHeaderOffset: offset,
+    }
+    const localHeader = writeZipLocalHeader(prepared, dos)
+    localParts.push(localHeader, prepared.bytes)
+    offset += localHeader.byteLength + prepared.bytes.byteLength
+    assertZipUint32(offset, 'Archive size')
+    preparedEntries.push(prepared)
+  }
+
+  const centralDirectoryOffset = offset
+  for (const entry of preparedEntries) {
+    const central = writeZipCentralDirectoryEntry(entry, dos)
+    centralParts.push(central)
+    offset += central.byteLength
+    assertZipUint32(offset, 'Archive size')
+  }
+
+  const centralDirectorySize = offset - centralDirectoryOffset
+  return concatBytes([
+    ...localParts,
+    ...centralParts,
+    writeZipEndOfCentralDirectory(preparedEntries.length, centralDirectorySize, centralDirectoryOffset),
+  ])
+}
+
+async function toArchiveBytes(data: AiraArchiveEntryData): Promise<Uint8Array> {
+  if (typeof data === 'string') {
+    return textEncoder.encode(data)
+  }
+  if (typeof Blob !== 'undefined' && data instanceof Blob) {
+    return new Uint8Array(await data.arrayBuffer())
+  }
+  if (data instanceof ArrayBuffer) {
+    return new Uint8Array(data)
+  }
+  if (ArrayBuffer.isView(data)) {
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
+  }
+  throw new Error('Archive entry data must be a string, Blob, ArrayBuffer, or ArrayBufferView.')
+}
+
+function inferProtocolNameFromAimd(aimd: string): string | null {
+  for (const line of aimd.split(/\r?\n/)) {
+    const trimmed = line.trim()
+    if (trimmed.startsWith('# ')) {
+      return trimmed.slice(2).trim() || null
+    }
+  }
+  return null
+}
+
+export async function createProtocolAiraArchive(options: CreateProtocolAiraArchiveOptions): Promise<Uint8Array> {
+  const entrypoint = normalizeArchiveMemberPath(options.protocol?.entrypoint ?? 'protocol.aimd', 'Protocol entrypoint')
+  const entries = new Map<string, Uint8Array>()
+  entries.set(entrypoint, textEncoder.encode(options.aimd))
+
+  for (const file of options.files ?? []) {
+    const path = normalizeArchiveMemberPath(file.path, 'Protocol file')
+    if (path === entrypoint || entries.has(path)) {
+      throw new Error(`Protocol archive contains duplicate file path '${path}'.`)
+    }
+    entries.set(path, await toArchiveBytes(file.data))
+  }
+
+  const fileNames = Array.from(entries.keys())
+  const fileHashes: Record<string, string> = {}
+  for (const [path, bytes] of entries) {
+    fileHashes[path] = await sha256Hex(bytes)
+  }
+
+  const manifest: AiraManifest = {
+    format: AIRA_ARCHIVE_FORMAT,
+    version: 1,
+    kind: 'protocol',
+    created_at: options.createdAt ?? new Date().toISOString(),
+    protocol: {
+      protocol_id: options.protocol?.protocol_id ?? null,
+      protocol_version: options.protocol?.protocol_version ?? null,
+      protocol_name: options.protocol?.protocol_name ?? inferProtocolNameFromAimd(options.aimd) ?? null,
+      entrypoint,
+      files: fileNames,
+      file_hashes: fileHashes,
+    },
+  }
+
+  const archiveEntries: ZipEntryPayload[] = [
+    {
+      name: AIRA_MANIFEST_PATH,
+      bytes: textEncoder.encode(`${JSON.stringify(manifest, null, 2)}\n`),
+    },
+    ...fileNames.map(name => ({ name, bytes: entries.get(name)! })),
+  ]
+  return createStoredZip(archiveEntries)
+}
+
 export class AiraArchive {
   readonly bytes: Uint8Array
   readonly entries: AiraEntry[]
@@ -407,14 +775,16 @@ export class AiraArchive {
       }
       recordPaths.add(path)
       let raw: Uint8Array
+      let parsedRecord: unknown
       try {
         raw = await this.readBytes(path)
-        JSON.parse(textDecoder.decode(raw))
+        parsedRecord = JSON.parse(textDecoder.decode(raw))
       }
       catch {
         issues.push(`Record file '${path}' is not valid UTF-8 JSON.`)
         continue
       }
+      issues.push(...validateRecordPayload(parsedRecord, `Record file '${path}'`))
       if (record.sha256) {
         const actualHash = await sha256Hex(raw)
         if (actualHash !== record.sha256) {