@prestack/thread 0.1.3 → 0.1.5

package/dist/integrity/slopnators/sl_undeclared_crossing.js

@@ -1,78 +1,442 @@
-import { descend, under } from "../../core/descend.js";
-import { here } from "./sl_unthreaded.js";
-const CROSSINGS = [
-    { what: 'the network', finds: /(?<![.\w])fetch\s*\(/ },
-    { what: 'the network', finds: /(?<![.\w])XMLHttpRequest\b/ },
-    { what: 'the clock', finds: /\bDate\s*\.\s*now\s*\(/ },
-    { what: 'the clock', finds: /\bperformance\s*\.\s*now\s*\(/ },
-    { what: 'the clock', finds: /\bsetInterval\s*\(/ },
-    { what: 'the clock', finds: /\bsetTimeout\s*\(/ },
-    { what: 'the clock', finds: /\brequestAnimationFrame\s*\(/ },
-    { what: 'randomness', finds: /\bMath\s*\.\s*random\s*\(/ },
-    { what: 'randomness', finds: /\bcrypto\s*\.\s*randomUUID\s*\(/ },
-    { what: 'the queue', finds: /\bqueue\s*\.\s*enqueue\s*\(/ },
-    { what: 'a seam', finds: /\b(?:files|llm|http)\s*\.\s*(?:call|run|complete|put|signedUrl|remove|get)\s*\(/ },
-];
-const OPERATIONS_ID = 'operations';
-const NODES_ID = 'nodes';
-let bodies;
-/*
- * The files this law is about, read off the tree rather than off a path.
- *
- * A crossing belongs in a declared node and nowhere else, so what the law has to know is which
- * files ARE declared nodes — every row in an operation's `seeds` that requires a node type. It
- * cannot be a path rule: an operation seeds its node bodies and its input file into the same
- * directory, so excepting the directory would except the input file too and leave a hole exactly
- * one file wide per operation. Measured 2026-08-27: with the directory excepted instead, this law
- * fired on `operations/wf_asks/asks_it.ts` — a node body calling the model its operation had
- * declared, which is the one place the law's own `instead` sends you.
- */
-function declared() {
-    if (bodies !== undefined)
-        return bodies;
-    const pass = descend();
-    const found = new Set();
-    for (const [at, threadings] of pass.threaded) {
-        for (const one of threadings) {
-            if (one.list !== 'seeds')
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import ts from 'typescript';
+import { ROOT, THREAD_AT, configured, descend, hosting, sources, under } from '../../core/descend.js';
+import { packageOf } from '../../core/attach.js';
+import { PREFIXES } from '../../core/thread.js';
+import { HOLDS, OPENS } from '../../integrations/target.js';
+const FROM_SOURCE = import.meta.url.endsWith('.ts');
+const OPENED_AT = fileURLToPath(new URL(FROM_SOURCE ? '../../operations/operations.ts' : '../../operations/operations.d.ts', import.meta.url));
+const HANDED = 'Opened';
+const EVERY = '';
+const IMPORTED = 'import ';
+const MADE = 'new ';
+const ANYWHERE = 'globalThis';
+const REQUIRED = 'require';
+const RUNTIME = 'node:';
+const SOURCE = /[.](?:ts|tsx|mts|cts)$/;
+const ROOTED = ROOT + '/';
+const here = (filename) => (filename.startsWith(ROOTED) ? filename.slice(ROOTED.length) : filename);
+const plain = (specifier) => (specifier.startsWith(RUNTIME) ? specifier.slice(RUNTIME.length) : specifier);
+const HANDS = Object.fromEntries(Object.keys(HOLDS).map((one) => [
+    one,
+    HOLDS[one].takes === 'entities' ? 'store' : HOLDS[one].takes === 'calls' ? 'target' : one,
+]));
+function opening() {
+    const found = {};
+    const add = (hand, spellings) => {
+        found[hand] = [...(found[hand] ?? []), ...spellings];
+    };
+    for (const [reach, spellings] of Object.entries(OPENS))
+        add(HANDS[reach] ?? reach, spellings);
+    return found;
+}
+function doors() {
+    const modules = new Map();
+    const members = new Map();
+    const globals = new Map();
+    const properties = new Map();
+    const made = new Map();
+    for (const [hand, spellings] of Object.entries(opening())) {
+        for (const spelling of spellings) {
+            const door = { hand, spelling };
+            if (spelling.startsWith(IMPORTED)) {
+                const rest = spelling.slice(IMPORTED.length);
+                const dot = rest.lastIndexOf('.');
+                if (dot === -1 || rest.slice(dot).includes('/')) {
+                    modules.set(plain(rest), door);
+                    continue;
+                }
+                const specifier = plain(rest.slice(0, dot));
+                const held = members.get(specifier) ?? new Map();
+                held.set(rest.slice(dot + 1), door);
+                members.set(specifier, held);
                 continue;
-            if (!under(pass, one.by, OPERATIONS_ID) || under(pass, one.by, NODES_ID))
+            }
+            if (spelling.startsWith(MADE)) {
+                made.set(spelling.slice(MADE.length), door);
                 continue;
-            if ((one.row.requires ?? []).length === 0)
+            }
+            if (spelling.includes('.'))
+                properties.set(spelling, door);
+            else
+                globals.set(spelling, door);
+        }
+    }
+    return { modules, members, globals, properties, made };
+}
+const DOORS = doors();
+const INTEGRATION = 'Integration';
+const NEEDS = 'needs';
+function needed(pass) {
+    const found = new Map();
+    const rows = [...pass.stated.values(), ...[...pass.threaded.values()].flat().map((one) => one.row)];
+    for (const row of rows) {
+        if (row.type !== INTEGRATION)
+            continue;
+        const held = row.fields.get(NEEDS);
+        if (held === undefined || !ts.isObjectLiteralExpression(held))
+            continue;
+        for (const one of held.properties) {
+            if (!ts.isPropertyAssignment(one))
                 continue;
-            found.add(at);
+            const name = ts.isStringLiteral(one.name) || ts.isIdentifier(one.name) ? one.name.text : undefined;
+            if (name !== undefined)
+                found.set(name, { hand: HANDS['sdk'] ?? 'sdk', spelling: IMPORTED + name });
         }
     }
-    bodies = found;
     return found;
 }
-export const slopnator = {
-    holds: (_node, at) => {
-        if (declared().has(here(at.filename)))
-            return false;
-        for (const crossing of CROSSINGS) {
-            if (!crossing.finds.test(at.text))
-                continue;
-            return (`${crossing.what} reached outside a declared node — nothing recorded this crossing, so it ` +
-                'cannot be replayed, retried, priced or unwound, and the page renders exactly the same either way');
+const moduleOf = (door) => door.spelling.slice(IMPORTED.length, door.spelling.lastIndexOf('.'));
+const stands = (door) => ', which the ' + door.hand + ' this app is handed stands in for';
+let built;
+function argumentsOf(type, checker) {
+    const found = [...(type.aliasTypeArguments ?? [])];
+    if ((type.flags & ts.TypeFlags.Object) !== 0 && (type.objectFlags & ts.ObjectFlags.Reference) !== 0) {
+        found.push(...checker.getTypeArguments(type));
+    }
+    return found;
+}
+function handed(type, checker, hand, into, seen, own) {
+    if (seen.has(type))
+        return;
+    seen.add(type);
+    if (type.isUnionOrIntersection()) {
+        for (const one of type.types)
+            handed(one, checker, hand, into, seen, own);
+        return;
+    }
+    for (const one of argumentsOf(type, checker))
+        handed(one, checker, hand, into, seen, own);
+    const index = checker.getIndexTypeOfType(type, ts.IndexKind.String);
+    if (index !== undefined)
+        handed(index, checker, hand, into, seen, own);
+    const symbol = type.getSymbol();
+    if (symbol === undefined || !own(symbol))
+        return;
+    if ((symbol.flags & (ts.SymbolFlags.Interface | ts.SymbolFlags.TypeLiteral | ts.SymbolFlags.Class)) === 0)
+        return;
+    if (!into.has(symbol))
+        into.set(symbol, hand);
+}
+function given(node, checker, into, own) {
+    const take = (one) => {
+        if (ts.isTypeReferenceNode(one)) {
+            const named = ts.isIdentifier(one.typeName) ? one.typeName : one.typeName.right;
+            const found = checker.getSymbolAtLocation(named);
+            const real = found !== undefined && (found.flags & ts.SymbolFlags.Alias) !== 0 ? checker.getAliasedSymbol(found) : found;
+            const shapes = ts.SymbolFlags.Interface | ts.SymbolFlags.Class | ts.SymbolFlags.TypeAlias;
+            if (real !== undefined && own(real) && (real.flags & shapes) !== 0 && !into.has(real))
+                into.set(real, EVERY);
+        }
+        ts.forEachChild(one, take);
+    };
+    const inside = (one) => {
+        if (ts.isMappedTypeNode(one)) {
+            if (one.type !== undefined)
+                take(one.type);
+            return;
+        }
+        ts.forEachChild(one, inside);
+    };
+    inside(node);
+}
+function compiled() {
+    const pass = descend();
+    if (built !== undefined && built.of === pass)
+        return built;
+    const options = configured().options;
+    const roots = [THREAD_AT, ...sources()].filter((one) => SOURCE.test(one)).map((one) => resolve(ROOT, one));
+    const program = ts.createProgram([...new Set([OPENED_AT, ...roots])], options, hosting(options));
+    const checker = program.getTypeChecker();
+    const hands = new Map();
+    const own = (symbol) => (symbol.getDeclarations() ?? []).some((one) => {
+        const from = one.getSourceFile();
+        return !program.isSourceFileDefaultLibrary(from) && !program.isSourceFileFromExternalLibrary(from);
+    });
+    const shape = program.getSourceFile(OPENED_AT);
+    for (const statement of shape?.statements ?? []) {
+        if (!ts.isTypeAliasDeclaration(statement) || statement.name.text !== HANDED)
+            continue;
+        const alias = checker.getSymbolAtLocation(statement.name);
+        if (alias !== undefined)
+            hands.set(alias, EVERY);
+        handed(checker.getTypeFromTypeNode(statement.type), checker, EVERY, hands, new Set(), own);
+        given(statement.type, checker, hands, own);
+    }
+    built = { of: pass, program, checker, hands, packages: needed(pass) };
+    return built;
+}
+const INTEGRATIONS_ID = 'integrations';
+function integral(pass, path) {
+    for (const [at, threadings] of pass.threaded) {
+        if (at !== path)
+            continue;
+        for (const one of threadings) {
+            if (one.by === INTEGRATIONS_ID || under(pass, one.by, INTEGRATIONS_ID))
+                return true;
+        }
+    }
+    return false;
+}
+function operational(pass, path) {
+    const prefixes = Object.values(PREFIXES);
+    const owned = (one) => prefixes.some((prefix) => one.startsWith(prefix));
+    if (path.split('/').some((part) => owned(part)))
+        return true;
+    for (const [at, threadings] of pass.threaded) {
+        if (at !== path)
+            continue;
+        for (const one of threadings) {
+            if (owned(one.by) || owned(String(one.row.id ?? '')))
+                return true;
+        }
+    }
+    return false;
+}
+function handOf(type, checker, hands, seen) {
+    if (seen.has(type))
+        return undefined;
+    seen.add(type);
+    const named = type.aliasSymbol === undefined ? undefined : hands.get(type.aliasSymbol);
+    if (named !== undefined)
+        return named;
+    if (type.isUnionOrIntersection()) {
+        for (const one of type.types) {
+            const found = handOf(one, checker, hands, seen);
+            if (found !== undefined)
+                return found;
+        }
+        return undefined;
+    }
+    const symbol = type.getSymbol() ?? type.aliasSymbol;
+    const own = symbol === undefined ? undefined : hands.get(symbol);
+    if (own !== undefined)
+        return own;
+    for (const one of argumentsOf(type, checker)) {
+        const found = handOf(one, checker, hands, seen);
+        if (found !== undefined)
+            return found;
+    }
+    return undefined;
+}
+function implemented(file, built) {
+    const found = new Set();
+    const { checker, hands } = built;
+    const held = checker.getSymbolAtLocation(file);
+    if (held === undefined)
+        return found;
+    const carries = (type, depth, seen) => {
+        if (seen.has(type))
+            return;
+        seen.add(type);
+        const hand = handOf(type, checker, hands, new Set());
+        if (hand !== undefined)
+            found.add(hand);
+        if (depth === 0)
+            return;
+        for (const one of type.isUnionOrIntersection() ? type.types : [type]) {
+            for (const signature of one.getCallSignatures())
+                carries(signature.getReturnType(), depth - 1, seen);
+            for (const property of one.getProperties())
+                carries(checker.getTypeOfSymbolAtLocation(property, file), depth - 1, seen);
+        }
+    };
+    for (const exported of checker.getExportsOfModule(held)) {
+        const real = (exported.flags & ts.SymbolFlags.Alias) !== 0 ? checker.getAliasedSymbol(exported) : exported;
+        if ((real.flags & ts.SymbolFlags.Value) === 0)
+            continue;
+        carries(checker.getTypeOfSymbolAtLocation(real, file), 2, new Set());
+    }
+    return found;
+}
+export const DOORWAY = 'door';
+export const HANDED_TO = 'hand';
+function judged(path, built, operates, wanted) {
+    const file = built.program.getSourceFile(resolve(ROOT, path));
+    if (file === undefined)
+        return [];
+    const { checker, hands } = built;
+    let door;
+    let allowed;
+    const may = (hand) => {
+        if (door === undefined)
+            door = integral(built.of, path);
+        if (allowed === undefined)
+            allowed = implemented(file, built);
+        return allowed.has(EVERY) || allowed.has(hand) || door || (operates && hand === EVERY);
+    };
+    const found = [];
+    const line = (node) => file.getLineAndCharacterOfPosition(node.getStart(file)).line + 1;
+    const note = (node, said, kind) => {
+        found.push({ line: line(node), said: 'line ' + String(line(node)) + ': ' + said, kind });
+    };
+    const locals = new Map();
+    const spaces = new Map();
+    const global = (id) => {
+        const symbol = checker.getSymbolAtLocation(id);
+        if (symbol === undefined)
+            return true;
+        const declared = symbol.getDeclarations() ?? [];
+        return declared.every((one) => one.getSourceFile().isDeclarationFile);
+    };
+    const named = (node) => {
+        const parent = node.parent;
+        return parent !== undefined && parent.name === node;
+    };
+    const inType = (node) => {
+        let up = node;
+        while (up !== undefined) {
+            if (ts.isTypeQueryNode(up))
+                return true;
+            up = up.parent;
         }
         return false;
-    },
+    };
+    const reaching = (specifier, node) => {
+        const door = DOORS.modules.get(plain(specifier)) ?? built.packages.get(packageOf(specifier));
+        if (door !== undefined && !may(door.hand))
+            note(node, 'imports ' + specifier + stands(door), DOORWAY);
+    };
+    const visit = (node) => {
+        if (ts.isImportDeclaration(node) && node.importClause?.isTypeOnly !== true && ts.isStringLiteral(node.moduleSpecifier)) {
+            reaching(node.moduleSpecifier.text, node);
+            const held = DOORS.members.get(plain(node.moduleSpecifier.text));
+            const bindings = node.importClause?.namedBindings;
+            if (held !== undefined && bindings !== undefined) {
+                if (ts.isNamespaceImport(bindings))
+                    spaces.set(bindings.name.text, held);
+                else {
+                    for (const element of bindings.elements) {
+                        const door = held.get((element.propertyName ?? element.name).text);
+                        if (door !== undefined)
+                            locals.set(element.name.text, door);
+                    }
+                }
+            }
+        }
+        if (ts.isExportDeclaration(node) && !node.isTypeOnly && node.moduleSpecifier !== undefined && ts.isStringLiteral(node.moduleSpecifier)) {
+            reaching(node.moduleSpecifier.text, node);
+        }
+        if (ts.isCallExpression(node)) {
+            const first = node.arguments[0];
+            const loads = node.expression.kind === ts.SyntaxKind.ImportKeyword || (ts.isIdentifier(node.expression) && node.expression.text === REQUIRED);
+            if (loads && first !== undefined && ts.isStringLiteral(first))
+                reaching(first.text, node);
+            const callee = node.expression;
+            if (ts.isPropertyAccessExpression(callee) || ts.isElementAccessExpression(callee)) {
+                const taken = callee.expression;
+                const hand = handOf(checker.getTypeAtLocation(taken), checker, hands, new Set()) ??
+                    (ts.isPropertyAccessExpression(taken) || ts.isElementAccessExpression(taken)
+                        ? handOf(checker.getTypeAtLocation(taken.expression), checker, hands, new Set())
+                        : undefined);
+                if (hand !== undefined && !may(hand)) {
+                    const what = ts.isPropertyAccessExpression(callee) ? callee.name.text : 'an order';
+                    note(node, 'calls ' + what + ' on ' + (hand === EVERY ? 'what this app hands an operation' : 'the ' + hand + ' it is handed'), HANDED_TO);
+                }
+            }
+        }
+        if (ts.isNewExpression(node) && ts.isIdentifier(node.expression) && (node.arguments ?? []).length === 0) {
+            const door = DOORS.made.get(node.expression.text);
+            if (door !== undefined && !may(door.hand) && global(node.expression))
+                note(node, 'reaches ' + door.spelling + '()' + stands(door), DOORWAY);
+        }
+        if (ts.isPropertyAccessExpression(node) && !ts.isPartOfTypeNode(node)) {
+            const inner = ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) && node.expression.expression.text === ANYWHERE ? node.expression.name : undefined;
+            const object = inner ?? node.expression;
+            if (ts.isIdentifier(object)) {
+                const spaced = spaces.get(object.text)?.get(node.name.text);
+                if (spaced !== undefined && !may(spaced.hand))
+                    note(node, 'reaches ' + node.name.text + ' from ' + moduleOf(spaced) + stands(spaced), DOORWAY);
+                const door = DOORS.properties.get(object.text + '.' + node.name.text);
+                if (door !== undefined && !may(door.hand) && (inner !== undefined || global(object)))
+                    note(node, 'reaches ' + door.spelling + stands(door), DOORWAY);
+                if (object.text === ANYWHERE) {
+                    const bare = DOORS.globals.get(node.name.text);
+                    if (bare !== undefined && !may(bare.hand))
+                        note(node, 'reaches ' + bare.spelling + stands(bare), DOORWAY);
+                }
+            }
+        }
+        if (ts.isIdentifier(node) && !named(node) && !ts.isPartOfTypeNode(node) && !inType(node)) {
+            const local = locals.get(node.text);
+            if (local !== undefined && !may(local.hand))
+                note(node, 'reaches ' + node.text + ' from ' + moduleOf(local) + stands(local), DOORWAY);
+            const door = DOORS.globals.get(node.text);
+            if (door !== undefined && !may(door.hand) && global(node))
+                note(node, 'reaches ' + door.spelling + stands(door), DOORWAY);
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(file);
+    return found.filter((one) => one.kind === wanted).sort((one, two) => one.line - two.line).map((one) => one.said);
+}
+export function judging(at, wanted, closing) {
+    const path = here(at.filename);
+    if (!SOURCE.test(path))
+        return false;
+    const held = compiled();
+    if (held.hands.size === 0 && resolve(ROOT, path) === OPENED_AT) {
+        return 'no type called ' + HANDED + ' can be read here, so nothing can tell what an operation was opened with from any other value, and a call on it outside an operation goes unmeasured';
+    }
+    const found = judged(path, held, operational(held.of, path), wanted);
+    if (found.length === 0)
+        return false;
+    return found.join('; ') + '. ' + closing;
+}
+export const slopnator = {
+    holds: (_node, at) => judging(at, DOORWAY, 'Each of these reaches past this process without going through a declared integration, and a reach this app never declared is one nothing can price, replay or unwind.'),
     proves: {
         wrong: [
-            "const res = await fetch('https://api.stripe.com/v1/charges')",
-            'const at = Date.now()',
-            'const id = crypto.randomUUID()',
-            "await queue.enqueue('job', payload)",
-            "await files.put('receipt.pdf', bytes)",
-            'const t = setInterval(() => refetch(), 5000)',
-            'const t = setTimeout(function again() { refetch(); setTimeout(again, 5000) }, 5000)',
-            'window.requestAnimationFrame(step)',
+            "import { spawnSync } from 'node:child_process'\n\nexport const ran = spawnSync('git', ['status'])",
+            "import * as processes from 'node:child_process'\n\nexport const ran = processes.spawnSync('git', ['status'])",
+            {
+                files: [
+                    { at: 'threads/thread.ts', source: "export const THREAD: Threaded = {\n  declares: [\n    { id: 'wf_thing', at: 'operations/wf_thing.ts' },\n  ],\n}\n" },
+                    { at: 'operations/wf_thing.ts', source: "export const asked = await fetch('https://example.com')" },
+                ],
+                at: 'operations/wf_thing.ts',
+            },
+            "import { PGlite } from '@electric-sql/pglite'\n\nexport const db = new PGlite()",
+            {
+                files: [
+                    { at: 'thread/core/thread.ts', source: 'export interface Threaded {\n  readonly id?: string\n  readonly at?: string\n  readonly describes?: string\n  readonly declares?: readonly Threaded[]\n}\n' },
+                    { at: 'threads/thread.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport interface Integration extends Threaded {\n  readonly needs?: Readonly<Record<string, string>>\n}\n\nexport const THREAD: Threaded = {\n  declares: [\n    { id: 'wf_pad', at: 'operations/wf_pad.ts' },\n  ],\n}\n\nexport const INTEGRATIONS: readonly Integration[] = [\n  { id: 'in_pad', describes: 'Pads text.', needs: { 'left-pad': '^1.3.0' } },\n]\n" },
+                    { at: 'operations/wf_pad.ts', source: "import pad from 'left-pad'\n\nexport const padded = pad('a', 3)\n" },
+                ],
+                at: 'operations/wf_pad.ts',
+            },
         ],
         right: [
-            "const node = { id: 'st_charge', kind: 'action', action: 'payment.charge', declares: { seams: ['http'] } }",
-            'const rows = useRead(recentOrders)',
-            "const { data } = useRead(recentOrders, { refresh: 'every-5s' })",
+            'export const began = Date.now()',
+            'export const later = setTimeout(() => again(), 5000)',
+            "import { randomBytes } from 'node:crypto'\n\nexport const nonce = randomBytes(6).toString('hex')",
+            "import { join } from 'node:path'\n\nexport const at = join('a', 'b')",
+            "import { createHash } from 'node:crypto'\n\nexport const sum = createHash('sha256').update('a').digest('hex')",
+            'export const when = new Date(1767225600000)',
+            {
+                files: [
+                    { at: 'thread/operations/operations.ts', source: 'export interface Http {\n  call(address: string): Promise<void>\n}\n\nexport type Opened<R extends string = never> = { readonly [K in R]: Http }\n' },
+                    { at: 'threads/_probe_door.ts', source: "import type { Http } from '../thread/operations/operations.ts'\n\nexport const made: Http = {\n  call: async (address) => {\n    await fetch(address)\n  },\n}\n" },
+                ],
+                at: 'threads/_probe_door.ts',
+            },
+            {
+                files: [
+                    { at: 'thread/operations/operations.ts', source: 'export interface Store {\n  insert(row: unknown): Promise<void>\n}\n\nexport type Opened<R extends string = never> = { readonly [K in R]: Store }\n' },
+                    { at: 'threads/_probe_handed.ts', source: "import type { Opened } from '../thread/operations/operations.ts'\n\nexport const carried = (opened: Opened<'pg_main'>, run: (given: Opened<'pg_main'>) => Promise<void>): Promise<void> => run(opened)\n" },
+                ],
+                at: 'threads/_probe_handed.ts',
+            },
+            {
+                files: [
+                    { at: 'thread/core/thread.ts', source: 'export interface Threaded {\n  readonly id?: string\n  readonly at?: string\n  readonly describes?: string\n  readonly declares?: readonly Threaded[]\n}\n' },
+                    { at: 'thread/operations/operations.ts', source: 'export type Calling = { readonly [call: string]: (given?: unknown) => Promise<unknown> }\n\nexport type Opened<R extends string = never> = { readonly [K in R]: Calling }\n' },
+                    { at: 'threads/thread.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport interface Integration extends Threaded {\n  readonly needs?: Readonly<Record<string, string>>\n}\n\nexport const THREAD: Threaded = {\n  declares: [\n    { id: 'sdk_pad_calls', at: 'src/sdk/sdk_pad.ts' },\n  ],\n}\n\nexport const INTEGRATIONS: readonly Integration[] = [\n  { id: 'in_pad', describes: 'Pads text.', needs: { 'left-pad': '^1.3.0' } },\n]\n" },
+                    { at: 'src/sdk/sdk_pad.ts', source: "import type { Calling } from '../../thread/operations/operations.ts'\nimport pad from 'left-pad'\n\nexport const calls: Calling = {\n  padded: async (given) => pad(String(given), 3),\n}\n" },
+                ],
+                at: 'src/sdk/sdk_pad.ts',
+            },
         ],
     },
 };