@meritt/shapeof-wasm 0.0.0-stage → 0.1.0

package/LICENSE

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

package/package.json

@@ -1,6 +1,52 @@
 {
   "name": "@meritt/shapeof-wasm",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Infers JSON Schema 2020-12 from examples of JSON, loose JSON or JSON Lines for structured outputs or validation, in WebAssembly",
+  "keywords": [
+    "json",
+    "json-schema",
+    "jsonl",
+    "structured-outputs",
+    "wasm",
+    "webassembly"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "Alexey Simonenko",
+    "email": "alexey@simonenko.dev",
+    "url": "https://simonenko.xyz"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/meritt/shapeof.rs.git",
+    "directory": "packages/npm"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=26.13.0"
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": "./shapeof.js",
+    "./shapeof.wasm": "./shapeof.wasm"
+  },
+  "files": [
+    "shapeof.js",
+    "shapeof.wasm"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "devEngines": {
+    "packageManager": {
+      "name": "pnpm",
+      "version": "^12.15.0",
+      "onFail": "download"
+    },
+    "runtime": {
+      "name": "node",
+      "version": "^26.13.0",
+      "onFail": "error"
+    }
+  }
 }

package/shapeof.js

@@ -0,0 +1,93 @@
+const VERSION = '0.1.0';
+const STATUS = ['ok', 'invalid_utf8', 'invalid_argument', 'internal'];
+const TARGETS = ['openai', 'anthropic', 'plain'];
+const OK = 0;
+// shapeof_report on wasm32: status, then the report as (pointer, length).
+const REPORT_SIZE = 12;
+
+export class ShapeOfError extends Error {
+  constructor(code) {
+    super(code);
+    this.name = 'ShapeOfError';
+    this.code = code;
+  }
+}
+
+export async function load(source = new URL('./shapeof.wasm', import.meta.url)) {
+  const module = await compile(source);
+  const { exports } = await WebAssembly.instantiate(module, {});
+  return new ShapeOf(exports);
+}
+
+async function compile(source) {
+  if (source instanceof WebAssembly.Module) return source;
+  if (typeof source === 'string') source = new URL(source, import.meta.url);
+  if (source instanceof URL) {
+    if (source.protocol === 'file:') {
+      const { readFile } = await import('node:fs/promises');
+      return WebAssembly.compile(await readFile(source));
+    }
+    source = fetch(source);
+  }
+  if (source instanceof Promise || source instanceof Response) {
+    return WebAssembly.compileStreaming(source);
+  }
+  return WebAssembly.compile(source);
+}
+
+const encoder = new TextEncoder();
+const decoder = new TextDecoder('utf-8', { fatal: true });
+
+class ShapeOf {
+  #x;
+
+  constructor(exports) {
+    this.#x = exports;
+    const version = typeof exports.shapeof_version === 'function' ? this.#cString(exports.shapeof_version()) : '';
+    if (version !== VERSION) throw new ShapeOfError('version');
+    this.version = VERSION;
+  }
+
+  schema(text, target) {
+    const index = TARGETS.indexOf(target);
+    if (typeof text !== 'string' || index < 0) throw new ShapeOfError('invalid_argument');
+    // A lone surrogate has no UTF-8 form; it reads as U+FFFD, like TextEncoder writes it.
+    const bytes = encoder.encode(text);
+    const x = this.#x;
+    const out = x.shapeof_alloc(REPORT_SIZE);
+    if (out === 0) throw new ShapeOfError('internal');
+    try {
+      this.#with(bytes, (p, n) => x.shapeof_infer(p, n, index, out));
+      // Read only after the call: memory may have grown and detached old views.
+      const view = new DataView(x.memory.buffer, out, REPORT_SIZE);
+      const status = view.getUint32(0, true);
+      if (status !== OK) throw new ShapeOfError(STATUS[status] ?? 'internal');
+      const report = new Uint8Array(x.memory.buffer, view.getUint32(4, true), view.getUint32(8, true));
+      const result = JSON.parse(decoder.decode(report));
+      x.shapeof_report_free(out);
+      return result;
+    } finally {
+      x.shapeof_dealloc(out, REPORT_SIZE);
+    }
+  }
+
+  #with(bytes, use) {
+    const x = this.#x;
+    const n = bytes.length;
+    const p = x.shapeof_alloc(n);
+    if (n > 0 && p === 0) throw new ShapeOfError('invalid_argument');
+    try {
+      new Uint8Array(x.memory.buffer, p, n).set(bytes);
+      return use(p, n);
+    } finally {
+      x.shapeof_dealloc(p, n);
+    }
+  }
+
+  #cString(p) {
+    const memory = new Uint8Array(this.#x.memory.buffer);
+    let end = p;
+    while (memory[end] !== 0) end++;
+    return decoder.decode(memory.subarray(p, end));
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.