@ouronet/talos-registry 1.1.0

package/dist/format.d.ts

@@ -0,0 +1,30 @@
+/** A guard argument: the NAME of the transaction-data key holding the keyset. */
+export interface KeysetRef {
+    readKeyset: string;
+}
+/**
+ * Render a JS value as a Pact literal for a DECLARED type.
+ *
+ * Every rule here is a bug someone already shipped.
+ */
+/**
+ * Pact's decimal lexer REJECTS a bare integer in a decimal slot: `5` is an integer literal and
+ * will not coerce, so an amount of 5 must be emitted as `5.0`. Number.toString() gives "5".
+ * This is the shipped defect the UI's builders call F-SEC-001.
+ */
+export declare function formatDecimal(v: unknown): string;
+export declare function formatInteger(v: unknown): string;
+/**
+ * Ouronet account ids are GLYPH strings and routinely contain characters that must survive
+ * verbatim. Escape only what Pact's string lexer requires -- a backslash and a double quote.
+ * Do NOT JSON.stringify: that would \\u-escape every non-ASCII glyph and change the account.
+ */
+export declare function formatString(v: unknown): string;
+export declare function formatBool(v: unknown): string;
+/**
+ * Render `value` for a parameter declared as `type`.
+ *
+ * Pact LIST literals are SPACE-separated, not comma-separated: `[1 2 3]`. A comma-joined list
+ * is a different expression and will not parse as the caller intends.
+ */
+export declare function formatForType(value: unknown, type: string): string;

package/dist/format.js

@@ -0,0 +1,113 @@
+import { RegistryError } from "./registry.js";
+/**
+ * Render a JS value as a Pact literal for a DECLARED type.
+ *
+ * Every rule here is a bug someone already shipped.
+ */
+/**
+ * Pact's decimal lexer REJECTS a bare integer in a decimal slot: `5` is an integer literal and
+ * will not coerce, so an amount of 5 must be emitted as `5.0`. Number.toString() gives "5".
+ * This is the shipped defect the UI's builders call F-SEC-001.
+ */
+export function formatDecimal(v) {
+    if (typeof v === "string") {
+        if (!/^-?\d+(\.\d+)?$/.test(v))
+            throw new RegistryError(`Not a decimal literal: "${v}"`);
+        return v.includes(".") ? v : v + ".0";
+    }
+    if (typeof v !== "number" || !Number.isFinite(v))
+        throw new RegistryError(`Expected a decimal, got ${JSON.stringify(v)}`);
+    // toFixed(12) rather than toString(): 1e-7 stringifies to "1e-7", which Pact cannot read.
+    // Trailing zeros are trimmed back, but at least one digit is always kept after the point.
+    const s = v.toFixed(12).replace(/0+$/, "");
+    return s.endsWith(".") ? s + "0" : s;
+}
+export function formatInteger(v) {
+    if (typeof v === "string" && /^-?\d+$/.test(v))
+        return v;
+    if (typeof v !== "number" || !Number.isInteger(v))
+        throw new RegistryError(`Expected an integer, got ${JSON.stringify(v)}`);
+    return String(v);
+}
+/**
+ * Ouronet account ids are GLYPH strings and routinely contain characters that must survive
+ * verbatim. Escape only what Pact's string lexer requires -- a backslash and a double quote.
+ * Do NOT JSON.stringify: that would \\u-escape every non-ASCII glyph and change the account.
+ */
+export function formatString(v) {
+    if (typeof v !== "string")
+        throw new RegistryError(`Expected a string, got ${JSON.stringify(v)}`);
+    return `"${v.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+export function formatBool(v) {
+    if (typeof v !== "boolean")
+        throw new RegistryError(`Expected a bool, got ${JSON.stringify(v)}`);
+    return v ? "true" : "false";
+}
+/** Pact object literal: `{ "k": v, ... }`. Keys are always quoted strings. */
+function formatObject(v, type) {
+    if (v === null || typeof v !== "object" || Array.isArray(v))
+        throw new RegistryError(`Expected an object for ${type}, got ${JSON.stringify(v)}`);
+    const body = Object.entries(v)
+        .map(([k, val]) => `${formatString(k)}: ${formatLoose(val)}`)
+        .join(", ");
+    return `{ ${body} }`;
+}
+/** Best-effort for values inside an untyped object, where no declared type is available. */
+function formatLoose(v) {
+    if (typeof v === "string")
+        return formatString(v);
+    if (typeof v === "boolean")
+        return formatBool(v);
+    if (typeof v === "number")
+        return Number.isInteger(v) ? String(v) : formatDecimal(v);
+    if (Array.isArray(v))
+        return `[${v.map(formatLoose).join(" ")}]`;
+    if (v && typeof v === "object")
+        return formatObject(v, "object");
+    throw new RegistryError(`Cannot render ${JSON.stringify(v)} as a Pact literal`);
+}
+/**
+ * Render `value` for a parameter declared as `type`.
+ *
+ * Pact LIST literals are SPACE-separated, not comma-separated: `[1 2 3]`. A comma-joined list
+ * is a different expression and will not parse as the caller intends.
+ */
+export function formatForType(value, type) {
+    const t = type.trim();
+    if (t.startsWith("[") && t.endsWith("]")) {
+        if (!Array.isArray(value))
+            throw new RegistryError(`Expected a list for ${t}, got ${JSON.stringify(value)}`);
+        const inner = t.slice(1, -1);
+        return `[${value.map(v => formatForType(v, inner)).join(" ")}]`;
+    }
+    switch (t) {
+        case "string": return formatString(value);
+        case "decimal": return formatDecimal(value);
+        case "integer": return formatInteger(value);
+        case "bool": return formatBool(value);
+        case "time": return formatString(value);
+    }
+    if (t === "guard" || t.startsWith("keyset")) {
+        // A guard is NEVER a literal. The calling convention across Ouronet is a `read-keyset`
+        // reference in the code, with the keyset itself in the transaction's `data` under that
+        // name -- `(coin.C_UR|TransferAnew "a" "b" (read-keyset "ks") 1.0)`.
+        //
+        // So this takes the NAME of the data key, not the keyset. Passing `{keys, pred}` is
+        // refused rather than serialised: inlining it would type-error at best, and at worst
+        // produce something that parses and means something else.
+        const name = typeof value === "string" ? value
+            : value && typeof value === "object" && typeof value.readKeyset === "string"
+                ? value.readKeyset
+                : null;
+        if (name === null) {
+            throw new RegistryError(`A \`${t}\` is passed as (read-keyset "<name>"), so this argument is the NAME of the ` +
+                `data key -- give "ks" or { readKeyset: "ks" }, and put the keyset itself in the ` +
+                `transaction's data under that name. Got ${JSON.stringify(value)}.`);
+        }
+        return `(read-keyset ${formatString(name)})`;
+    }
+    if (t === "object" || t.startsWith("object{"))
+        return formatObject(value, t);
+    throw new RegistryError(`No rendering rule for declared type "${t}".`);
+}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @ouronet/talos-registry — the Ouronet callable surface, generated from the deployed contracts.
+ *
+ * A consumer supplies VALUES. It never types a function name, an argument order, or an arity.
+ *
+ * The registry is a BUNDLED SNAPSHOT, pinned at build time. That is deliberate: refreshing at
+ * runtime would add a trust surface (whatever a node returns) and a failure mode (offline means
+ * no registry) that a pinned artefact does not have. `surfaceHash` identifies exactly which
+ * surface a build was compiled against.
+ */
+export { registry, surfaceHash, namespace, RegistryError, getEntrypoint, tryGetEntrypoint, getPreview, entrypointKeys, modules, entrypointsOfModule, resolveByName } from "./registry.js";
+export { buildCall, buildPreviewCall, buildGhostCall } from "./build.js";
+export type { BuildOptions } from "./build.js";
+export { planCall, explainCall } from "./plan.js";
+export type { CallPlan } from "./plan.js";
+export { parseCapability, parseCapabilities, capabilityRecipe } from "./caps.js";
+export type { ParsedCapability, CapabilityRecipe } from "./caps.js";
+export { formatForType, formatDecimal, formatInteger, formatString, formatBool } from "./format.js";
+export type * from "./types.js";

package/dist/index.js

@@ -0,0 +1,15 @@
+/**
+ * @ouronet/talos-registry — the Ouronet callable surface, generated from the deployed contracts.
+ *
+ * A consumer supplies VALUES. It never types a function name, an argument order, or an arity.
+ *
+ * The registry is a BUNDLED SNAPSHOT, pinned at build time. That is deliberate: refreshing at
+ * runtime would add a trust surface (whatever a node returns) and a failure mode (offline means
+ * no registry) that a pinned artefact does not have. `surfaceHash` identifies exactly which
+ * surface a build was compiled against.
+ */
+export { registry, surfaceHash, namespace, RegistryError, getEntrypoint, tryGetEntrypoint, getPreview, entrypointKeys, modules, entrypointsOfModule, resolveByName } from "./registry.js";
+export { buildCall, buildPreviewCall, buildGhostCall } from "./build.js";
+export { planCall, explainCall } from "./plan.js";
+export { parseCapability, parseCapabilities, capabilityRecipe } from "./caps.js";
+export { formatForType, formatDecimal, formatInteger, formatString, formatBool } from "./format.js";

package/dist/plan.d.ts

@@ -0,0 +1,32 @@
+import type { ExecutionMode, OwnershipClause } from "./types.js";
+/** An ordered, human-readable plan for performing one operation correctly. */
+export interface CallPlan {
+    key: string;
+    mode: ExecutionMode;
+    /** reads to run BEFORE building the transaction, in no particular order */
+    preflight: string[];
+    /** the reader that computes required capabilities, if any */
+    capabilityReader: string | null;
+    /** accounts whose key the caller must be able to sign for */
+    mustSignFor: OwnershipClause[];
+    /** true when the gas station pays; "step-0-only" for a defpact */
+    sponsored: boolean | "step-0-only";
+    /** how many transactions this operation takes, when the registry can say */
+    transactions: "one" | "many-parallel" | "many-sequential" | "many-continuation";
+    /** the single most important thing to get right */
+    warnings: string[];
+    /** a supported alternative, when this route is not the supported one */
+    preferInstead: string | null;
+}
+/**
+ * Everything a consumer must do to perform one operation, in order.
+ *
+ * Reading the registry field by field is possible but invites cherry-picking: the four
+ * launchpad buys need a capability read that has nothing to do with their inputs, the ten
+ * defpacts need a continuation whose gas the customer pays, and three pagers must not be
+ * fired concurrently. Those facts live in different keys, and a consumer who checks one and
+ * not the others gets a transaction that submits and does the wrong thing.
+ */
+export declare function planCall(key: string): CallPlan;
+/** Render a plan as text -- for a CLI, a code comment, or a docs page. */
+export declare function explainCall(key: string): string;

package/dist/plan.js

@@ -0,0 +1,79 @@
+import { getEntrypoint } from "./registry.js";
+/**
+ * Everything a consumer must do to perform one operation, in order.
+ *
+ * Reading the registry field by field is possible but invites cherry-picking: the four
+ * launchpad buys need a capability read that has nothing to do with their inputs, the ten
+ * defpacts need a continuation whose gas the customer pays, and three pagers must not be
+ * fired concurrently. Those facts live in different keys, and a consumer who checks one and
+ * not the others gets a transaction that submits and does the wrong thing.
+ */
+export function planCall(key) {
+    const ep = getEntrypoint(key);
+    const ex = ep.execution;
+    const warnings = [];
+    const transactions = ex.mode === "defpact" ? "many-continuation"
+        : ex.mode === "indirect-parallel" ? "many-parallel"
+            : ex.mode === "indirect-sequential" ? "many-sequential"
+                : "one";
+    if (ex.mode === "indirect-sequential")
+        warnings.push("STRICTLY ORDERED. Each call advances a stored cursor, so firing pages concurrently " +
+            "races it -- submit one, confirm, then the next, until the preflight reports done.");
+    if (ex.mode === "indirect-parallel")
+        warnings.push("Order-independent: the slices MAY be submitted together. Cut them from the preflight; " +
+            "do not invent the partition.");
+    if (ex.mode === "defpact") {
+        warnings.push(`MULTI-TRANSACTION by continuation: ${ex.steps ?? "?"} steps. Step 0 runs on submit; the ` +
+            "rest are `cont` payloads against the pact id the first result returns. Submitting once " +
+            "and reporting success leaves the operation half-finished.");
+        warnings.push("CONTINUATIONS ARE NOT GAS-SPONSORED. Chainweb injects `exec-code` only for `exec` " +
+            "payloads, and DALOS.GAS_PAYER reads it eagerly, so it cannot evaluate a `cont`. " +
+            "Step 0 is sponsored; the CUSTOMER account pays for every later step.");
+    }
+    if (ep.externalCaps)
+        warnings.push(`Requires capabilities beyond GAS_PAYER. Call ${ep.externalCaps.computedBy} and attach ` +
+            `what it returns -- do NOT recompute the amounts; they depend on live price and a ` +
+            `slippage pad, and a self-derived figure signs a capability the contract will not match.`);
+    for (const c of ep.ownership.requires ?? [])
+        if (c.when === "CONDITIONAL")
+            warnings.push(`Ownership of ${c.account} is CONDITIONAL: ${c.conditionalOn ?? ""}`.trim());
+    if (ep.ownership.unmapped?.length)
+        warnings.push(`Ownership enforces exist deeper in the call tree that the registry could not map to this ` +
+            `entrypoint's parameters (${ep.ownership.unmapped.join(", ")}). Treat the list as ` +
+            `INCOMPLETE, not as "nothing else is required".`);
+    if (!ep.preview)
+        warnings.push(`No cost preview exists. ${ep.previewMissing ?? ""}`.trim());
+    return {
+        key,
+        mode: ex.mode,
+        preflight: (ex.preflight ?? []).filter((p) => typeof p === "string"),
+        capabilityReader: ex.capabilityPreflight ?? null,
+        mustSignFor: ep.ownership.requires ?? [],
+        sponsored: ep.sponsorship.sponsored,
+        transactions,
+        warnings,
+        preferInstead: ex.preferInstead ?? null,
+    };
+}
+/** Render a plan as text -- for a CLI, a code comment, or a docs page. */
+export function explainCall(key) {
+    const p = planCall(key);
+    const L = [`${p.key}  [${p.mode}, ${p.transactions} transaction(s)]`];
+    if (p.preferInstead)
+        L.push(`  PREFER INSTEAD: ${p.preferInstead}`);
+    L.push(`  gas: ${p.sponsored === true ? "sponsored by the Ouronet gas station"
+        : p.sponsored === "step-0-only" ? "step 0 sponsored; continuations paid by the customer"
+            : "NOT sponsored -- the caller pays"}`);
+    if (p.preflight.length)
+        L.push(`  preflight: ${p.preflight.join(", ")}`);
+    if (p.capabilityReader)
+        L.push(`  capabilities from: ${p.capabilityReader}`);
+    if (p.mustSignFor.length) {
+        L.push("  must sign for:");
+        for (const c of p.mustSignFor)
+            L.push(`    - ${c.account} [${c.when}] -- ${c.meaning}`);
+    }
+    for (const w of p.warnings)
+        L.push(`  ! ${w}`);
+    return L.join("\n");
+}

package/dist/registry.d.ts

@@ -0,0 +1,34 @@
+import type { Entrypoint, Preview, RegistryDoc } from "./types.js";
+/** The bundled snapshot. Pinned at build time; never fetched at runtime. */
+export declare const registry: RegistryDoc;
+/** Identifies exactly which surface this build was compiled against. */
+export declare const surfaceHash: string;
+export declare const namespace: string;
+/** Thrown for every refusal in this package, so a consumer can catch one class. */
+export declare class RegistryError extends Error {
+    constructor(message: string);
+}
+/**
+ * Look up an entrypoint by its FULL `MODULE.function` key.
+ *
+ * Throws on an unknown key rather than returning undefined, and the message lists near
+ * matches -- because the failure this package exists to prevent is a name that no longer
+ * resolves, and on chain that surfaces as a RESOLUTION error which `try` cannot catch and
+ * consumers render as missing data.
+ */
+export declare function getEntrypoint(key: string): Entrypoint;
+export declare function tryGetEntrypoint(key: string): Entrypoint | undefined;
+export declare function getPreview(key: string): Preview | undefined;
+export declare function entrypointKeys(): string[];
+export declare function modules(): string[];
+export declare function entrypointsOfModule(module: string): string[];
+/**
+ * Resolve a BARE function name to its full key.
+ *
+ * Refuses when the name is ambiguous instead of picking one. Four SWP liquidity names resolve
+ * to two modules with IDENTICAL signatures and DIFFERENT execution modes -- one single
+ * transaction, one defpact -- so guessing is silent in both directions: address the defpact
+ * believing it direct and the operation sits half-finished; address the direct one believing
+ * it a defpact and there is no pact for the continuation to continue.
+ */
+export declare function resolveByName(fn: string): string;

package/dist/registry.js

@@ -0,0 +1,69 @@
+import data from "./data/registry.json" with { type: "json" };
+/** The bundled snapshot. Pinned at build time; never fetched at runtime. */
+export const registry = data;
+/** Identifies exactly which surface this build was compiled against. */
+export const surfaceHash = registry.surfaceHash;
+export const namespace = registry.namespace;
+/** Thrown for every refusal in this package, so a consumer can catch one class. */
+export class RegistryError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "RegistryError";
+    }
+}
+/**
+ * Look up an entrypoint by its FULL `MODULE.function` key.
+ *
+ * Throws on an unknown key rather than returning undefined, and the message lists near
+ * matches -- because the failure this package exists to prevent is a name that no longer
+ * resolves, and on chain that surfaces as a RESOLUTION error which `try` cannot catch and
+ * consumers render as missing data.
+ */
+export function getEntrypoint(key) {
+    const hit = registry.entrypoints[key];
+    if (hit)
+        return hit;
+    const [, fn = key] = key.split(/\.(.*)/s);
+    const near = Object.keys(registry.entrypoints).filter(k => k.endsWith("." + fn));
+    throw new RegistryError(near.length
+        ? `Unknown entrypoint "${key}". The same function exists on: ${near.join(", ")}. ` +
+            `Entrypoints are addressed MODULE.function.`
+        : `Unknown entrypoint "${key}". It is not in surface ${surfaceHash}; either the name is ` +
+            `stale or the module is not deployed.`);
+}
+export function tryGetEntrypoint(key) {
+    return registry.entrypoints[key];
+}
+export function getPreview(key) {
+    return registry.previews[key];
+}
+export function entrypointKeys() {
+    return Object.keys(registry.entrypoints);
+}
+export function modules() {
+    return [...new Set(entrypointKeys().map(k => k.split(".", 1)[0]))].sort();
+}
+export function entrypointsOfModule(module) {
+    return entrypointKeys().filter(k => k.startsWith(module + "."));
+}
+/**
+ * Resolve a BARE function name to its full key.
+ *
+ * Refuses when the name is ambiguous instead of picking one. Four SWP liquidity names resolve
+ * to two modules with IDENTICAL signatures and DIFFERENT execution modes -- one single
+ * transaction, one defpact -- so guessing is silent in both directions: address the defpact
+ * believing it direct and the operation sits half-finished; address the direct one believing
+ * it a defpact and there is no pact for the continuation to continue.
+ */
+export function resolveByName(fn) {
+    const hits = entrypointKeys().filter(k => k.split(/\.(.*)/s)[1] === fn);
+    if (hits.length === 1)
+        return hits[0];
+    if (hits.length === 0)
+        throw new RegistryError(`No entrypoint named "${fn}".`);
+    const detail = hits
+        .map(k => `${k} (${registry.entrypoints[k].execution.mode})`)
+        .join(", ");
+    throw new RegistryError(`"${fn}" is ambiguous -- it resolves to ${hits.length} modules: ${detail}. ` +
+        `Address it as MODULE.function.`);
+}

package/dist/types.d.ts

@@ -0,0 +1,163 @@
+/**
+ * The shape of Deploy/OURONET-REGISTRY.json.
+ *
+ * Generated by REPL/tools/_registry.py in the Pact repo, which reads the CHAIN via
+ * `describe-module` and falls back to the sources only for modules not yet deployed. So the
+ * authority here is what is CALLABLE, not what someone intends to deploy.
+ */
+/** One parameter, in declaration order. Position is the calling convention. */
+export interface Param {
+    name: string;
+    type: string;
+}
+/** How a call executes -- see `ExecutionMode`. */
+export type ExecutionMode = 
+/** the provided inputs suffice; nothing is read off-chain first */
+"direct"
+/** ONE transaction, but a preflight read supplies some argument */
+ | "indirect-single"
+/** a preflight is cut into slices, one per transaction, ORDER-INDEPENDENT */
+ | "indirect-parallel"
+/** a preflight reports progress; each call advances a stored cursor. STRICTLY ORDERED */
+ | "indirect-sequential"
+/** multi-transaction by CONTINUATION: step 0 on submit, the rest are `cont` payloads */
+ | "defpact";
+export interface FedParam {
+    param: string;
+    type: string;
+    /** the read(s) that produce this value. A client cannot construct it. */
+    producedBy: string[];
+    /** for a fed slice, what cuts the preflight's output into per-transaction slices */
+    slicedBy: string[] | null;
+}
+export interface Continuation {
+    payload: "cont";
+    pactId: string;
+    step: string;
+    rollback: string;
+    /** empty for every defpact in Ouronet: no step reads client input */
+    data: Record<string, never>;
+    dataNote: string;
+    /** the surprise: continuations are NOT gas-sponsored. Step 0 is. */
+    gas: string;
+}
+export interface Execution {
+    mode: ExecutionMode;
+    shape?: string;
+    note: string;
+    /** reads to run BEFORE building the transaction */
+    preflight?: string[] | null;
+    fedParams?: FedParam[] | null;
+    preflightUnresolved?: boolean;
+    /** defpact only */
+    pact?: string;
+    steps?: number;
+    rollbackSteps?: number;
+    inputs?: ExecutionMode;
+    continuation?: Continuation;
+    /** false when a supported single-transaction twin exists -- see preferInstead */
+    supported?: boolean;
+    preferInstead?: string;
+    supportedNote?: string;
+    /** the reader that computes this call's required capabilities */
+    capabilityPreflight?: string;
+}
+export interface OwnershipClause {
+    /** the account, or "owner of `<entity>`" when a lookup is needed */
+    account: string;
+    via: "parameter" | "reader";
+    /** ALWAYS = unconditional. CONDITIONAL = binds on one branch only. */
+    when: "ALWAYS" | "CONDITIONAL";
+    meaning: string;
+    reader?: string;
+    subject?: string;
+    conditionalOn?: string;
+}
+export interface Ownership {
+    resolved: boolean;
+    requires?: OwnershipClause[];
+    /** subjects found deeper in the call tree that could not be mapped to a parameter */
+    unmapped?: string[] | null;
+    unmappedNote?: string;
+    reason?: string;
+}
+export interface Sponsorship {
+    /** true, false, or "step-0-only" for a defpact whose continuations the customer pays */
+    sponsored: boolean | "step-0-only";
+    sponsor?: string;
+    cap?: string;
+    capArgs?: Param[];
+    suppliedBy?: string | null;
+    conditional?: string | null;
+    stepsNote?: string;
+}
+export interface ExternalCaps {
+    required: true;
+    /** the READER that computes the capability arguments -- it IS the formula */
+    computedBy: string;
+    readerParams: Param[];
+    /** reader parameter -> this entrypoint's parameter, or a note when client-supplied */
+    argsFrom: Record<string, string>;
+    returns: string;
+    format: string;
+    parse: string;
+    attachTo: string;
+    note: string;
+}
+export interface Ghost {
+    /** example arguments by parameter name. `null` means "obtain from the preflight". */
+    args: Record<string, unknown>;
+    source: string;
+    notes?: Record<string, string>;
+    unresolved?: string[];
+    unresolvedNote?: string;
+    warning: string;
+}
+export interface Entrypoint {
+    params: Param[];
+    /** declared return type, or null when the signature does not pin one */
+    returns: string | null;
+    returnsNote?: string;
+    source: "deployed" | "repo-only";
+    modulePath: string;
+    moduleHash?: string;
+    callable?: false;
+    note?: string;
+    ownership: Ownership;
+    sponsorship: Sponsorship;
+    execution: Execution;
+    externalCaps?: ExternalCaps;
+    ghost: Ghost;
+    /** the INFO_ reader that prices this call */
+    preview?: string;
+    previewVia?: string;
+    previewMissing?: string;
+}
+export interface Preview {
+    params: Param[];
+    returns: string | null;
+    source: "deployed" | "repo-only";
+    modulePath: string;
+    moduleHash?: string;
+}
+export interface Divergence {
+    module: string;
+    function: string;
+    deployed: Param[] | null;
+    repo: Param[] | null;
+}
+export interface RegistryDoc {
+    note: string;
+    namespace: string;
+    generatedFrom: "chain+repo" | "repo-only";
+    entrypoints: Record<string, Entrypoint>;
+    previews: Record<string, Preview>;
+    /** bare names that resolve to more than one module -- ALWAYS address MODULE.function */
+    nameCollisions: Record<string, {
+        module: string;
+        mode: ExecutionMode;
+    }[]>;
+    divergences: Divergence[];
+    notDeployed: string[];
+    surfaceHash: string;
+}

package/dist/types.js

@@ -0,0 +1,8 @@
+/**
+ * The shape of Deploy/OURONET-REGISTRY.json.
+ *
+ * Generated by REPL/tools/_registry.py in the Pact repo, which reads the CHAIN via
+ * `describe-module` and falls back to the sources only for modules not yet deployed. So the
+ * authority here is what is CALLABLE, not what someone intends to deploy.
+ */
+export {};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@ouronet/talos-registry",
+  "version": "1.1.0",
+  "description": "The Ouronet callable surface, generated from the deployed contracts. Supply values; never type a function name.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/types.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "sync": "node scripts/sync-registry.mjs",
+    "build": "npm run sync && tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "clean": "rimraf dist",
+    "sync:check": "node scripts/sync-registry.mjs --check"
+  },
+  "keywords": [
+    "ouronet",
+    "pact",
+    "kadena",
+    "stoachain",
+    "registry"
+  ],
+  "license": "UNLICENSED",
+  "devDependencies": {
+    "typescript": "^5.6.0",
+    "vitest": "^2.1.0",
+    "rimraf": "^6.0.0"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  }
+}