@tanstack-ai-browser/afm 0.0.0-stage → 0.2.2

package/dist/schema.js

@@ -0,0 +1,133 @@
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** Drops undefined fields: the native bridge takes JSON. */
+function defined(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, v]) => v !== undefined));
+}
+const isNull = (schema) => isObject(schema) && (schema.type === "null" || (Array.isArray(schema.type) && schema.type.length === 1 && schema.type[0] === "null"));
+/** Whether a schema allows null: `type: [..., "null"]`, or a null choice in `anyOf`. */
+function nullable(schema) {
+    if (!isObject(schema))
+        return false;
+    if (Array.isArray(schema.type) && schema.type.includes("null"))
+        return true;
+    const variants = schema.anyOf ?? schema.oneOf;
+    return Array.isArray(variants) && variants.some(isNull);
+}
+const number = (value) => (typeof value === "number" && Number.isFinite(value) ? value : undefined);
+/** A schema's name for the framework: letters, digits and underscores. */
+const typeName = (name) => name.replace(/[^A-Za-z0-9_]/g, "_") || "Value";
+/**
+ * The framework's schema for a JSON Schema, named `name` (a tool's name, or
+ * the structured answer's).
+ */
+export function toNativeSchema(schema, name) {
+    const json = isObject(schema) ? schema : {};
+    const defs = { ...(isObject(json.definitions) ? json.definitions : {}), ...(isObject(json.$defs) ? json.$defs : {}) };
+    const definitions = new Map();
+    const convert = (value, path) => {
+        if (!isObject(value))
+            return { kind: "string" };
+        if (typeof value.$ref === "string") {
+            const target = value.$ref.split("/").at(-1) ?? "";
+            const def = defs[target];
+            if (!isObject(def))
+                return { kind: "string" };
+            const converted = definitions.get(target) ?? convertDefinition(def, target);
+            // Only named schemas (objects, choices) can be referred to.
+            return converted.kind === "object" || converted.kind === "anyOf" ? { kind: "reference", name: typeName(target) } : converted;
+        }
+        if ("const" in value && typeof value.const === "string")
+            return { kind: "string", constant: value.const };
+        if (Array.isArray(value.enum)) {
+            const members = value.enum.filter((v) => v !== null);
+            if (members.every((v) => typeof v === "string")) {
+                return members.length > 0 ? { kind: "string", choices: members } : { kind: "string" };
+            }
+            // true and false both: any boolean. One alone, the framework can't hold it to.
+            if (members.every((v) => typeof v === "boolean")) {
+                if (new Set(members).size === 2)
+                    return { kind: "boolean" };
+                throw new Error(`${path}: an enum of only ${String(members[0])} isn't supported (Apple's framework can't hold a boolean to one value)`);
+            }
+            // Integers (and strings among them): a choice of exact values, each integer
+            // a range of itself, which the framework holds the model to. A decimal
+            // can't be: a range of one decimal fails in Apple's generator.
+            if (members.some((v) => typeof v === "number" && !Number.isInteger(v))) {
+                throw new Error(`${path}: an enum of decimal numbers isn't supported (Apple's framework can't hold a decimal to exact values)`);
+            }
+            if (members.every((v) => typeof v === "string" || Number.isInteger(v))) {
+                const choices = members.map((v) => typeof v === "string" ? { kind: "string", constant: v } : { kind: "integer", minimum: v, maximum: v });
+                if (choices.length === 1)
+                    return choices[0];
+                return defined({ kind: "anyOf", name: typeName(path), description: typeof value.description === "string" ? value.description : undefined, choices });
+            }
+            throw new Error(`${path}: an enum mixing ${[...new Set(members.map((v) => typeof v))].join(" and ")} values isn't supported by Apple's framework`);
+        }
+        const variants = value.anyOf ?? value.oneOf;
+        if (Array.isArray(variants)) {
+            const choices = variants.filter((v) => !isNull(v));
+            if (choices.length === 1)
+                return convert({ ...choices[0], description: value.description ?? choices[0].description }, path);
+            if (choices.length > 1) {
+                return defined({
+                    kind: "anyOf",
+                    name: typeName(path),
+                    description: typeof value.description === "string" ? value.description : undefined,
+                    choices: choices.map((choice, i) => convert(choice, `${path}_${i + 1}`))
+                });
+            }
+        }
+        const types = Array.isArray(value.type) ? value.type.filter((t) => t !== "null") : [value.type];
+        const type = typeof types[0] === "string" ? types[0] : isObject(value.properties) ? "object" : value.items ? "array" : "string";
+        switch (type) {
+            case "object": {
+                const required = Array.isArray(value.required) ? value.required : [];
+                const properties = Object.entries(isObject(value.properties) ? value.properties : {}).map(([key, property]) => defined({
+                    name: key,
+                    description: isObject(property) && typeof property.description === "string" ? property.description : undefined,
+                    optional: !required.includes(key) || nullable(property),
+                    schema: convert(property, `${path}_${key}`)
+                }));
+                return defined({
+                    kind: "object",
+                    name: typeName(path),
+                    description: typeof value.description === "string" ? value.description : undefined,
+                    properties
+                });
+            }
+            case "array":
+                return defined({
+                    kind: "array",
+                    items: convert(Array.isArray(value.items) ? value.items[0] : value.items, `${path}_item`),
+                    minimumElements: number(value.minItems),
+                    maximumElements: number(value.maxItems)
+                });
+            case "integer":
+            case "number":
+                return defined({
+                    kind: type,
+                    minimum: number(value.minimum) ?? number(value.exclusiveMinimum),
+                    maximum: number(value.maximum) ?? number(value.exclusiveMaximum)
+                });
+            case "boolean":
+                return { kind: "boolean" };
+            case "null":
+                return { kind: "null" };
+            default:
+                return { kind: "string" };
+        }
+    };
+    const convertDefinition = (def, target) => {
+        // Set first, so a definition that refers to itself finds its name.
+        definitions.set(target, { kind: "object", name: typeName(target), properties: [] });
+        const converted = convert(def, target);
+        const named = converted.kind === "object" || converted.kind === "anyOf" ? { ...converted, name: typeName(target) } : converted;
+        definitions.set(target, named);
+        return named;
+    };
+    const root = convert(json, name);
+    return {
+        root,
+        definitions: [...definitions.values()].filter((d) => d.kind === "object" || d.kind === "anyOf")
+    };
+}

package/dist/validate.d.ts

@@ -0,0 +1,2 @@
+export declare function schemaErrors(schema: unknown, value: unknown): Array<string>;
+//# sourceMappingURL=validate.d.ts.map

package/dist/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../src/validate.ts"],"names":[],"mappings":"AAiCA,wBAAgB,YAAY,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK,CAAC,MAAM,CAAC,CA8E3E"}

package/dist/validate.js

@@ -0,0 +1,124 @@
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const typeOf = (value) => (value === null ? "null" : Array.isArray(value) ? "array" : typeof value);
+function equal(a, b) {
+    if (a === b)
+        return true;
+    if (Array.isArray(a) && Array.isArray(b))
+        return a.length === b.length && a.every((v, i) => equal(v, b[i]));
+    if (isObject(a) && isObject(b)) {
+        const keys = Object.keys(a);
+        return keys.length === Object.keys(b).length && keys.every((k) => Object.hasOwn(b, k) && equal(a[k], b[k]));
+    }
+    return false;
+}
+function fitsType(type, value) {
+    if (type === "integer")
+        return typeof value === "number" && Number.isInteger(value);
+    if (type === "number")
+        return typeof value === "number" && Number.isFinite(value);
+    return typeOf(value) === type;
+}
+const show = (value) => JSON.stringify(value);
+export function schemaErrors(schema, value) {
+    const root = isObject(schema) ? schema : {};
+    const errors = [];
+    const resolve = (ref) => {
+        const match = /^#\/(\$defs|definitions)\/(.+)$/.exec(ref);
+        const defs = match ? root[match[1]] : undefined;
+        return match && isObject(defs) ? defs[decodeURIComponent(match[2])] : undefined;
+    };
+    const check = (s, v, path, out) => {
+        if (s === true || s === undefined)
+            return;
+        if (s === false)
+            return void out.push(`${path || "/"}: not allowed`);
+        if (!isObject(s))
+            return;
+        if (typeof s.$ref === "string") {
+            const target = resolve(s.$ref);
+            if (target === undefined)
+                return void out.push(`${path || "/"}: unknown $ref ${s.$ref}`);
+            check(target, v, path, out);
+        }
+        const at = path || "/";
+        if ("const" in s && !equal(s.const, v))
+            out.push(`${at}: should be ${show(s.const)}, not ${show(v)}`);
+        if (Array.isArray(s.enum) && !s.enum.some((e) => equal(e, v)))
+            out.push(`${at}: ${show(v)} is not one of ${s.enum.map(show).join(", ")}`);
+        if (s.type !== undefined) {
+            const types = (Array.isArray(s.type) ? s.type : [s.type]).filter((t) => typeof t === "string");
+            if (types.length > 0 && !types.some((t) => fitsType(t, v))) {
+                out.push(`${at}: should be ${types.join(" or ")}, not ${typeOf(v)}`);
+                return;
+            }
+        }
+        if (Array.isArray(s.allOf))
+            for (const part of s.allOf)
+                check(part, v, path, out);
+        for (const key of ["anyOf", "oneOf"]) {
+            const choices = s[key];
+            if (!Array.isArray(choices))
+                continue;
+            const fitting = choices.filter((choice) => {
+                const sub = [];
+                check(choice, v, path, sub);
+                return sub.length === 0;
+            }).length;
+            if (key === "anyOf" ? fitting === 0 : fitting !== 1)
+                out.push(`${at}: fits ${fitting} of its ${key} choices`);
+        }
+        if (isObject(v)) {
+            const properties = isObject(s.properties) ? s.properties : {};
+            if (Array.isArray(s.required)) {
+                for (const key of s.required)
+                    if (typeof key === "string" && !Object.hasOwn(v, key))
+                        out.push(`${path}/${key}: missing`);
+            }
+            for (const [key, item] of Object.entries(v)) {
+                if (Object.hasOwn(properties, key))
+                    check(properties[key], item, `${path}/${key}`, out);
+                else if (s.additionalProperties === false)
+                    out.push(`${path}/${key}: not a property of the schema`);
+                else if (isObject(s.additionalProperties))
+                    check(s.additionalProperties, item, `${path}/${key}`, out);
+            }
+        }
+        if (Array.isArray(v)) {
+            if (typeof s.minItems === "number" && v.length < s.minItems)
+                out.push(`${at}: fewer than ${s.minItems} items`);
+            if (typeof s.maxItems === "number" && v.length > s.maxItems)
+                out.push(`${at}: more than ${s.maxItems} items`);
+            if (Array.isArray(s.items))
+                s.items.forEach((item, i) => i < v.length && check(item, v[i], `${path}/${i}`, out));
+            else if (s.items !== undefined)
+                v.forEach((item, i) => check(s.items, item, `${path}/${i}`, out));
+        }
+        if (typeof v === "string") {
+            if (typeof s.minLength === "number" && [...v].length < s.minLength)
+                out.push(`${at}: shorter than ${s.minLength}`);
+            if (typeof s.maxLength === "number" && [...v].length > s.maxLength)
+                out.push(`${at}: longer than ${s.maxLength}`);
+            if (typeof s.pattern === "string") {
+                try {
+                    if (!new RegExp(s.pattern, "u").test(v))
+                        out.push(`${at}: doesn't match ${s.pattern}`);
+                }
+                catch {
+                    // A pattern JavaScript can't read isn't checked.
+                }
+            }
+        }
+        if (typeof v === "number") {
+            if (typeof s.minimum === "number" && v < s.minimum)
+                out.push(`${at}: less than ${s.minimum}`);
+            if (typeof s.maximum === "number" && v > s.maximum)
+                out.push(`${at}: more than ${s.maximum}`);
+            if (typeof s.exclusiveMinimum === "number" && v <= s.exclusiveMinimum)
+                out.push(`${at}: not more than ${s.exclusiveMinimum}`);
+            if (typeof s.exclusiveMaximum === "number" && v >= s.exclusiveMaximum)
+                out.push(`${at}: not less than ${s.exclusiveMaximum}`);
+        }
+    };
+    check(root, value, "", errors);
+    return errors;
+}

package/electron/AfmNode.swift

@@ -0,0 +1,81 @@
+// AfmBridge for the Node-API addon (afm.c) that serveAfm() loads: plain C functions,
+// JSON strings in and out, built into one afm.node with AfmCore (build.mjs). macOS only.
+import Foundation
+
+/// The C function the addon gives for events: called with each event in JSON, from
+/// any thread.
+public typealias AfmListener = @convention(c) (UnsafePointer<CChar>) -> Void
+
+private final class State: @unchecked Sendable {
+    let lock = NSLock()
+    var listener: AfmListener?
+    var bridge: AnyObject?
+}
+
+private let state = State()
+
+private func json(_ object: Any) -> String {
+    guard JSONSerialization.isValidJSONObject(object),
+          let data = try? JSONSerialization.data(withJSONObject: object) else { return "{}" }
+    return String(decoding: data, as: UTF8.self)
+}
+
+private func emit(_ event: [String: Any]) {
+    let listener = state.lock.withLock { state.listener }
+    guard let listener else { return }
+    json(event).withCString { listener($0) }
+}
+
+@available(macOS 26.0, *)
+private func bridge() -> AfmBridge {
+    state.lock.withLock {
+        if let bridge = state.bridge as? AfmBridge { return bridge }
+        let bridge = AfmBridge { emit($0) }
+        state.bridge = bridge
+        return bridge
+    }
+}
+
+/// Sets the function events go to.
+@_cdecl("afm_set_listener")
+public func afm_set_listener(_ listener: AfmListener?) {
+    state.lock.withLock { state.listener = listener }
+}
+
+/// Calls one of AfmBridge's methods with its options in JSON. Returns
+/// `{ "result": … }` or `{ "error": … }` in JSON, which the caller frees with `afm_free`.
+@_cdecl("afm_call")
+public func afm_call(_ method: UnsafePointer<CChar>, _ options: UnsafePointer<CChar>) -> UnsafeMutablePointer<CChar> {
+    let name = String(cString: method)
+    let object = (try? JSONSerialization.jsonObject(with: Data(String(cString: options).utf8))) as? [String: Any] ?? [:]
+    var reply: [String: Any]
+    if #available(macOS 26.0, *) {
+        do {
+            switch name {
+            case "availability": reply = ["result": AfmBridge.availability(object)]
+            case "createSession": try bridge().createSession(object); reply = ["result": NSNull()]
+            case "prewarm": try bridge().prewarm(object); reply = ["result": NSNull()]
+            case "respond": try bridge().respond(object); reply = ["result": NSNull()]
+            case "submitToolResult": try bridge().submitToolResult(object); reply = ["result": NSNull()]
+            case "cancel": try bridge().cancel(object); reply = ["result": NSNull()]
+            case "deleteSession":
+                bridge().deleteSession(object["sessionId"] as? String ?? "")
+                reply = ["result": NSNull()]
+            default: reply = ["error": "Unknown method \(name)"]
+            }
+        } catch {
+            reply = ["error": String(describing: error)]
+        }
+    } else {
+        reply = name == "availability"
+            ? ["result": ["available": false, "reason": "unsupportedOS"]]
+            : ["error": "Apple's on-device model needs macOS 26 or later"]
+    }
+    return strdup(json(reply))!
+}
+
+/// Frees a string `afm_call` returned.
+@_cdecl("afm_free")
+public func afm_free(_ pointer: UnsafeMutablePointer<CChar>?) {
+    free(pointer)
+}

package/electron/afm.c

@@ -0,0 +1,94 @@
+// The Node-API addon around AfmBridge (AfmNode.swift): `call(method, optionsJson)`
+// returns `{ result }` or `{ error }` in JSON, and `setListener(fn)` gets each
+// event in JSON. Events come from Swift's threads, so they reach JavaScript through
+// a thread-safe function, on Node's own thread.
+#define NAPI_VERSION 8
+#include <node_api.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef void (*afm_listener)(const char *json);
+extern void afm_set_listener(afm_listener listener);
+extern char *afm_call(const char *method, const char *options);
+extern void afm_free(char *pointer);
+
+static napi_threadsafe_function events = NULL;
+
+static void call_js(napi_env env, napi_value callback, void *context, void *data) {
+    (void)context;
+    char *json = data;
+    if (env != NULL && callback != NULL) {
+        napi_value argument, undefined;
+        napi_create_string_utf8(env, json, NAPI_AUTO_LENGTH, &argument);
+        napi_get_undefined(env, &undefined);
+        napi_call_function(env, undefined, callback, 1, &argument, NULL);
+    }
+    free(json);
+}
+
+static void on_event(const char *json) {
+    napi_threadsafe_function target = events;
+    if (target == NULL) return;
+    char *copy = strdup(json);
+    if (napi_call_threadsafe_function(target, copy, napi_tsfn_nonblocking) != napi_ok) free(copy);
+}
+
+static char *string_argument(napi_env env, napi_value value) {
+    size_t length = 0;
+    if (napi_get_value_string_utf8(env, value, NULL, 0, &length) != napi_ok) return NULL;
+    char *string = malloc(length + 1);
+    napi_get_value_string_utf8(env, value, string, length + 1, &length);
+    return string;
+}
+
+static napi_value set_listener(napi_env env, napi_callback_info info) {
+    size_t count = 1;
+    napi_value arguments[1];
+    napi_get_cb_info(env, info, &count, arguments, NULL, NULL);
+    if (events != NULL) {
+        afm_set_listener(NULL);
+        napi_release_threadsafe_function(events, napi_tsfn_abort);
+        events = NULL;
+    }
+    napi_valuetype type = napi_undefined;
+    if (count > 0) napi_typeof(env, arguments[0], &type);
+    if (type == napi_function) {
+        napi_value name;
+        napi_create_string_utf8(env, "afm events", NAPI_AUTO_LENGTH, &name);
+        napi_create_threadsafe_function(env, arguments[0], NULL, name, 0, 1, NULL, NULL, NULL, call_js, &events);
+        // Events don't keep the process running.
+        napi_unref_threadsafe_function(env, events);
+        afm_set_listener(on_event);
+    }
+    return NULL;
+}
+
+static napi_value call(napi_env env, napi_callback_info info) {
+    size_t count = 2;
+    napi_value arguments[2];
+    napi_get_cb_info(env, info, &count, arguments, NULL, NULL);
+    char *method = count > 0 ? string_argument(env, arguments[0]) : NULL;
+    char *options = count > 1 ? string_argument(env, arguments[1]) : NULL;
+    if (method == NULL || options == NULL) {
+        free(method);
+        free(options);
+        napi_throw_type_error(env, NULL, "call(method, optionsJson) takes two strings");
+        return NULL;
+    }
+    char *reply = afm_call(method, options);
+    napi_value result;
+    napi_create_string_utf8(env, reply, NAPI_AUTO_LENGTH, &result);
+    afm_free(reply);
+    free(method);
+    free(options);
+    return result;
+}
+
+NAPI_MODULE_INIT() {
+    napi_property_descriptor properties[] = {
+        { "call", NULL, call, NULL, NULL, NULL, napi_default, NULL },
+        { "setListener", NULL, set_listener, NULL, NULL, NULL, napi_default, NULL }
+    };
+    napi_define_properties(env, exports, 2, properties);
+    return exports;
+}

package/electron/afm.node.sha256

@@ -0,0 +1 @@
+7242528a429eafaaa0928604d5ca0130429ded1465d72e765876097777d1f9e1

package/electron/build.mjs

@@ -0,0 +1,54 @@
+// Builds the Node-API addon serveAfm() loads, electron/afm.node: the Swift bridge
+// (ios/Sources/AfmCore, which the Capacitor plugin uses too), AfmNode.swift (its C
+// functions) and afm.c (Node-API), in one Mach-O bundle for Apple silicon Macs.
+// Node-API is the same in every Node and Electron, so one build loads in all of them.
+// Needs Xcode on macOS.
+//
+//   node electron/build.mjs
+import { execFileSync } from "node:child_process"
+import { readdirSync, writeFileSync } from "node:fs"
+import { createRequire } from "node:module"
+import { dirname, join } from "node:path"
+import { fileURLToPath } from "node:url"
+
+const here = dirname(fileURLToPath(import.meta.url))
+const require = createRequire(import.meta.url)
+const core = join(here, "..", "ios", "Sources", "AfmCore")
+const headers = join(dirname(require.resolve("node-api-headers/package.json")), "include")
+// The oldest macOS the addon loads on; Apple's model needs macOS 26 (checked at run time).
+const target = "arm64-apple-macos13.0"
+
+const run = (command, args) => execFileSync("xcrun", [command, ...args], { stdio: "inherit" })
+
+const object = join(here, "afm.o")
+run("clang", ["-c", "-O2", "-target", target, "-I", headers, join(here, "afm.c"), "-o", object])
+run("swiftc", [
+  "-O",
+  "-emit-library",
+  "-module-name",
+  "AfmNode",
+  "-target",
+  target,
+  ...readdirSync(core)
+    .filter((file) => file.endsWith(".swift"))
+    .map((file) => join(core, file)),
+  join(here, "AfmNode.swift"),
+  object,
+  "-o",
+  join(here, "afm.node"),
+  // Node-API comes from the process that loads the addon.
+  "-Xlinker",
+  "-undefined",
+  "-Xlinker",
+  "dynamic_lookup",
+  // macOS before 26 has no FoundationModels: the addon still loads there.
+  "-Xlinker",
+  "-weak_framework",
+  "-Xlinker",
+  "FoundationModels"
+])
+execFileSync("rm", ["-f", object])
+// Which sources this addon is from: committed with it, and checked by a test.
+const { hashFile, sourcesHash } = await import("./sources-hash.mjs")
+writeFileSync(hashFile, `${sourcesHash()}\n`)
+console.log(`Built ${join(here, "afm.node")}`)

package/electron/preload.cjs

@@ -0,0 +1,35 @@
+// The preload serveAfm() adds to the app's pages: Apple's on-device model as
+// window.afm (the AfmNative interface), which afmText() finds on its own. The main
+// process runs the model; this only talks to it. CommonJS needing nothing but
+// Electron, as a sandboxed preload must.
+"use strict"
+
+const { contextBridge, ipcRenderer } = require("electron")
+
+const call =
+  (method) =>
+  (options = {}) =>
+    ipcRenderer.invoke("afm:call", method, options)
+
+const afm = {
+  availability: call("availability"),
+  createSession: call("createSession"),
+  prewarm: call("prewarm"),
+  respond: call("respond"),
+  submitToolResult: call("submitToolResult"),
+  cancel: call("cancel"),
+  deleteSession: call("deleteSession"),
+  addListener(_name, listener) {
+    const forward = (_event, event) => listener(event)
+    ipcRenderer.on("afm:event", forward)
+    return Promise.resolve({
+      remove: () => {
+        ipcRenderer.removeListener("afm:event", forward)
+        return Promise.resolve()
+      }
+    })
+  }
+}
+
+if (process.contextIsolated) contextBridge.exposeInMainWorld("afm", afm)
+else globalThis.afm = afm

package/electron/sources-hash.mjs

@@ -0,0 +1,40 @@
+// The addon's sources, hashed: electron/afm.node is committed (so packages build
+// without Xcode), and electron/afm.node.sha256 records which sources it was built
+// from. build.mjs writes it; a test fails when the sources no longer match, so a
+// change to the Swift or C can't ship with a stale addon.
+import { createHash } from "node:crypto"
+import { readdirSync, readFileSync } from "node:fs"
+import { dirname, join, relative } from "node:path"
+import { fileURLToPath } from "node:url"
+
+const here = dirname(fileURLToPath(import.meta.url))
+const root = join(here, "..")
+
+/** The files afm.node is built from, in a fixed order. */
+export function sourceFiles() {
+  const core = join(root, "ios", "Sources", "AfmCore")
+  return [
+    ...readdirSync(core)
+      .filter((file) => file.endsWith(".swift"))
+      .sort()
+      .map((file) => join(core, file)),
+    join(here, "AfmNode.swift"),
+    join(here, "afm.c"),
+    join(here, "build.mjs")
+  ]
+}
+
+/** A SHA-256 of the sources: each file's path (from the package) and contents. */
+export function sourcesHash() {
+  const hash = createHash("sha256")
+  for (const file of sourceFiles()) {
+    hash.update(relative(root, file))
+    hash.update("\0")
+    hash.update(readFileSync(file))
+    hash.update("\0")
+  }
+  return hash.digest("hex")
+}
+
+/** Where the hash of the sources the committed addon was built from is kept. */
+export const hashFile = join(here, "afm.node.sha256")