@jigging/jig 0.1.0-alpha.15 → 0.1.0-alpha.19

package/libexec/authoring/node_modules/@jigging/flow-authoring/dist/lower.js

@@ -0,0 +1,477 @@
+import { getDocData, getMaxItemsAsNumeric, getMaxLengthAsNumeric, getMaxValueAsNumeric, getMaxValueExclusiveAsNumeric, getMinItemsAsNumeric, getMinLengthAsNumeric, getMinValueAsNumeric, getMinValueExclusiveAsNumeric, isArrayModelType, } from '@typespec/compiler';
+import { fail } from './errors.js';
+import { channelKey, closedKey, invocationKey, oneOfKey, projectionKey } from './library.js';
+import { channelReference } from './values.js';
+export const schemaId = 'https://flow.jig.md/schemas/schema-0.json';
+export const contractId = 'https://flow.jig.md/schemas/invocation-contract-0.schema.json';
+const channelId = 'https://flow.jig.md/schemas/channel-contract-0.schema.json';
+const definitionName = /^[A-Za-z][A-Za-z0-9]{0,63}(?![\s\S])/;
+const reservedTypes = new Set('Array FlowInput FlowResult any unknown never undefined string number boolean bigint symbol object void null true false default import export class enum extends interface type break case catch const continue debugger delete do else finally for function if in instanceof new return super switch this throw try typeof var while with yield let static await implements private protected public package infer keyof readonly unique is asserts as satisfies abstract declare namespace module require global'.split(' '));
+const localName = /^[a-z0-9]+(?:-[a-z0-9]+)*(?![\s\S])/;
+const getters = [
+    ['minLength', getMinLengthAsNumeric],
+    ['maxLength', getMaxLengthAsNumeric],
+    ['minItems', getMinItemsAsNumeric],
+    ['maxItems', getMaxItemsAsNumeric],
+    ['minimum', getMinValueAsNumeric],
+    ['maximum', getMaxValueAsNumeric],
+    ['exclusiveMinimum', getMinValueExclusiveAsNumeric],
+    ['exclusiveMaximum', getMaxValueExclusiveAsNumeric],
+];
+function number(value, target) {
+    const n = typeof value === 'number' ? value : value.asNumber();
+    if (n === null || !Number.isFinite(n) || (Number.isInteger(n) && !Number.isSafeInteger(n))) {
+        fail('SOURCE_UNSUPPORTED', 'This number cannot be represented exactly within JSON/0.', target);
+    }
+    return n === 0 ? 0 : n;
+}
+export function lower(program, channelContracts = new Set()) {
+    const entries = [...program.stateMap(invocationKey)];
+    if (entries.length !== 1)
+        fail('SOURCE_INVALID', 'Declare exactly one @invocation on a namespace.');
+    const [owner, invocation] = entries[0];
+    const globals = program.getGlobalNamespaceType();
+    if (owner.models.size + owner.unions.size > 1024) {
+        fail('SCHEMA_LIMIT', 'The descriptor supports at most 1024 shared definitions.', owner);
+    }
+    if (owner.namespace !== globals ||
+        owner.namespaces.size ||
+        [...globals.namespaces.keys()].some((n) => !['FLOW', 'TypeSpec', owner.name].includes(n)) ||
+        globals.models.size ||
+        globals.scalars.size ||
+        globals.unions.size) {
+        fail('SOURCE_UNSUPPORTED', 'Use one top-level invocation namespace for all authored models.', owner);
+    }
+    const opts = invocation.options;
+    if (!opts ||
+        typeof opts !== 'object' ||
+        Array.isArray(opts) ||
+        Object.keys(opts).some((k) => !['outcomes', 'id', 'version', 'features', 'channels'].includes(k))) {
+        fail('SOURCE_UNSUPPORTED', 'Invocation options support outcomes, id/version, optional features and named channel ports.', owner);
+    }
+    if (opts.id !== undefined || opts.version !== undefined || opts.features !== undefined)
+        identity(opts, owner);
+    if (opts.features !== undefined) {
+        const features = record(opts.features, owner, 'Feature catalog');
+        if (Object.keys(features).length > 256 ||
+            Object.entries(features).some(([name, description]) => !localName.test(name) ||
+                name.length > 64 ||
+                typeof description !== 'string' ||
+                [...description].length < 1 ||
+                [...description].length > 16384))
+            fail('SOURCE_INVALID', 'Features must map at most 256 LocalNames to descriptions of 1–16384 Unicode scalars.', owner);
+    }
+    const ports = Object.create(null);
+    if (opts.channels !== undefined) {
+        const channels = record(opts.channels, owner, 'channels');
+        if (Object.keys(channels).length > 256)
+            fail('SOURCE_LIMIT', 'Too many channel ports.', owner);
+        for (const [name, value] of Object.entries(channels)) {
+            const port = record(value, owner, 'channel port');
+            if (!localName.test(name) ||
+                name.length > 64 ||
+                Object.keys(port).some((key) => !['direction', 'contract', 'required', 'delivery', 'start'].includes(key)) ||
+                !['send', 'receive'].includes(port.direction) ||
+                typeof port.contract !== 'string' ||
+                !channelReference(port.contract) ||
+                (port.required !== undefined && typeof port.required !== 'boolean') ||
+                (port.delivery !== undefined &&
+                    !['direct', 'broadcast'].includes(port.delivery)) ||
+                (port.start !== undefined &&
+                    (port.direction !== 'receive' || !['beginning', 'suffix'].includes(port.start))))
+                fail('SOURCE_INVALID', 'Channel ports require a direction and a package-local JSON contract.', owner);
+            ports[name] = port;
+        }
+    }
+    if (opts.outcomes !== undefined) {
+        const outcomes = opts.outcomes;
+        if (!outcomes ||
+            typeof outcomes !== 'object' ||
+            Array.isArray(outcomes) ||
+            Object.keys(outcomes).length > 256 ||
+            Object.entries(outcomes).some(([k, v]) => !localName.test(k) ||
+                ['done', 'failed', 'cancelled', 'error'].includes(k) ||
+                typeof v !== 'string' ||
+                [...v].length < 1 ||
+                [...v].length > 16384)) {
+            fail('SOURCE_INVALID', 'Outcomes must map permitted names to nonempty bounded descriptions.', owner);
+        }
+    }
+    const definitions = Object.create(null);
+    const origins = new WeakMap();
+    const pending = new Set();
+    let count = 0;
+    const authored = (t) => 'namespace' in t && t.namespace === owner;
+    const named = (t) => authored(t) && (t.kind === 'Model' || t.kind === 'Union') && !!t.name;
+    function constraints(schema, target) {
+        for (const [key, getter] of getters) {
+            const value = getter(program, target);
+            if (value === undefined)
+                continue;
+            const n = number(value, target);
+            const previous = schema[key];
+            // Derived constraints can narrow a base scalar, never erase its bounds.
+            schema[key] =
+                previous === undefined
+                    ? n
+                    : key.startsWith('max')
+                        ? Math.min(previous, n)
+                        : key === 'exclusiveMaximum'
+                            ? Math.min(previous, n)
+                            : Math.max(previous, n);
+        }
+        return schema;
+    }
+    function emit(t, depth = 1, expandNamed = false) {
+        if (depth > 64 || ++count > 4096)
+            fail('SCHEMA_LIMIT', 'The emitted schema exceeds its graph limits.', t);
+        if (pending.has(t))
+            fail('SOURCE_UNSUPPORTED', 'Recursive model graphs are not supported.', t);
+        if (named(t) && !expandNamed) {
+            if (!definitionName.test(t.name) || reservedTypes.has(t.name)) {
+                fail('SOURCE_UNSUPPORTED', 'Use a distinct Schema/0 definition name (FlowInput and FlowResult are reserved).', t);
+            }
+            if (!definitions[t.name]) {
+                // Namespace maps distinguish model kinds; prevent cross-kind definition collision.
+                const collision = [...owner.models.values(), ...owner.unions.values()].filter((v) => v.name === t.name);
+                if (collision.length !== 1)
+                    fail('SOURCE_INVALID', 'Definition name collision.', t);
+                definitions[t.name] = emit(t, depth + 1, true);
+            }
+            const ref = { $ref: `#/$defs/${t.name}` };
+            origins.set(ref, t);
+            return ref;
+        }
+        pending.add(t);
+        let out;
+        switch (t.kind) {
+            case 'ModelProperty':
+                if (t.defaultValue)
+                    fail('SOURCE_UNSUPPORTED', 'Defaults are not supported.', t);
+                out = constraints({ ...emit(t.type, depth + 1) }, t);
+                break;
+            case 'Scalar':
+                if (authored(t)) {
+                    if (!t.baseScalar)
+                        fail('SOURCE_UNSUPPORTED', 'A scalar needs a supported primitive base.', t);
+                    out = constraints({ ...emit(t.baseScalar, depth + 1) }, t);
+                }
+                else if (t.namespace?.name === 'TypeSpec' &&
+                    ['string', 'integer', 'float64', 'boolean'].includes(t.name)) {
+                    out = { type: t.name === 'float64' ? 'number' : t.name };
+                }
+                else {
+                    fail('SOURCE_UNSUPPORTED', `Scalar ${t.name} is not supported; use string, integer, float64 or boolean.`, t);
+                }
+                break;
+            case 'String':
+                out = { const: t.value };
+                break;
+            case 'Number':
+                out = { const: number(t.numericValue, t) };
+                break;
+            case 'Boolean':
+                out = { const: t.value };
+                break;
+            case 'Intrinsic':
+                if (t.name !== 'null')
+                    fail('SOURCE_UNSUPPORTED', `Intrinsic ${t.name} is unsupported.`, t);
+                out = { type: 'null' };
+                break;
+            case 'Model':
+                if (isArrayModelType(program, t)) {
+                    out = { type: 'array', items: emit(t.indexer.value, depth + 1) };
+                }
+                else {
+                    if (!authored(t) || !program.stateMap(closedKey).has(t) || t.indexer) {
+                        fail('SOURCE_UNSUPPORTED', 'Object models must be authored and explicitly @closed.', t);
+                    }
+                    const properties = Object.create(null);
+                    const required = [];
+                    for (const [name, property] of t.properties) {
+                        properties[name] = emit(property, depth + 1);
+                        if (!property.optional)
+                            required.push(name);
+                    }
+                    out = { type: 'object', properties, required, additionalProperties: false };
+                }
+                break;
+            case 'Union': {
+                const variants = [...t.variants.values()].map((v) => emit(v.type, depth + 1));
+                if (!variants.length)
+                    fail('SOURCE_UNSUPPORTED', 'Empty unions are not supported.', t);
+                if (program.stateMap(oneOfKey).has(t))
+                    out = { oneOf: variants };
+                else if (variants.every((v) => Object.keys(v).length === 1 && typeof v.const === 'string')) {
+                    out = { enum: [...new Set(variants.map((v) => v.const))] };
+                }
+                else
+                    out = { anyOf: variants };
+                break;
+            }
+            default:
+                fail('SOURCE_UNSUPPORTED', `Type ${t.kind} is outside this profile.`, t);
+        }
+        const doc = getDocData(program, t);
+        if (doc?.source === 'decorator')
+            out.description = doc.value;
+        pending.delete(t);
+        origins.set(out, t);
+        return out;
+    }
+    // Validate unused declarations too; otherwise unsupported constructs can hide.
+    for (const t of [...owner.models.values(), ...owner.scalars.values(), ...owner.unions.values()])
+        emit(t);
+    const descriptor = {
+        $schema: contractId,
+        $defs: definitions,
+        input: emit(invocation.input),
+        result: emit(invocation.result),
+        ...(opts.outcomes === undefined ? {} : { outcomes: opts.outcomes }),
+        ...(opts.id === undefined ? {} : { id: opts.id, version: opts.version }),
+        ...(opts.features === undefined ? {} : { features: opts.features }),
+        ...(opts.channels === undefined ? {} : { channels: ports }),
+    };
+    const channels = Object.create(null);
+    for (const [type, value] of program.stateMap(channelKey)) {
+        const { path, options } = value;
+        if (!authored(type) ||
+            typeof path !== 'string' ||
+            !/^\.\/[a-z][a-z0-9-]*\.channel\.json(?![\s\S])/.test(path))
+            fail('SOURCE_INVALID', 'Channel outputs use a root ./name.channel.json path.', type);
+        const metadata = record(options, type, 'channel options');
+        identity(metadata, type);
+        if (Object.keys(metadata).some((key) => !['id', 'version', 'semantics'].includes(key)) ||
+            typeof metadata.semantics !== 'string' ||
+            !metadata.semantics.length ||
+            Buffer.byteLength(metadata.semantics) > 16384)
+            fail('SOURCE_INVALID', 'Channel options require id, version and bounded semantics.', type);
+        const file = path.slice(2);
+        if (Object.hasOwn(channels, file))
+            fail('SOURCE_INVALID', 'Two channels select the same output path.', type, file);
+        channels[file] = {
+            $schema: channelId,
+            id: metadata.id,
+            version: metadata.version,
+            semantics: metadata.semantics,
+            item: emit(type),
+            $defs: reachableDefinitions(emit(type), definitions),
+        };
+    }
+    for (const port of Object.values(ports)) {
+        if (!Object.hasOwn(channels, port.contract.slice(2)) && !channelContracts.has(port.contract))
+            fail('SOURCE_INVALID', 'Every port must reference a generated channel or a supplied offline contract.', owner, port.contract);
+    }
+    const projections = Object.create(null);
+    for (const [type, path] of program.stateMap(projectionKey)) {
+        if (!authored(type) ||
+            typeof path !== 'string' ||
+            !/^\.\/[a-z][a-z0-9-]*\.schema\.json(?![\s\S])/.test(path)) {
+            fail('SOURCE_UNSUPPORTED', 'Agent outputs use a root ./name.schema.json path.', type);
+        }
+        const file = path.slice(2);
+        if (['input.schema.json', 'result.schema.json', 'settings.schema.json'].includes(file))
+            fail('SOURCE_INVALID', 'Agent projections cannot replace reserved package schema owners.', type, file);
+        if (projections[file])
+            fail('SOURCE_INVALID', 'Two projections select the same output path.', type, file);
+        const expanded = expand(emit(type), definitions, origins, file);
+        checkAgent(expanded, origins, file);
+        projections[file] = { $schema: schemaId, ...expanded };
+    }
+    if (Object.keys(channels).length + Object.keys(projections).length > 63)
+        fail('SOURCE_LIMIT', 'At most 63 channel and Agent schema outputs are supported.', owner);
+    const identities = new Map();
+    for (const channel of Object.values(channels)) {
+        const key = `${channel.id}\0${channel.version}`;
+        const shape = JSON.stringify(channel);
+        if (identities.has(key) && identities.get(key) !== shape)
+            fail('SOURCE_INVALID', 'Channel identity has conflicting declarations.', owner);
+        identities.set(key, shape);
+    }
+    return { descriptor, projections, channels, declarations: declarations(descriptor) };
+}
+// A channel's identity must not change when unrelated invocation models change.
+function reachableDefinitions(schema, definitions) {
+    const selected = Object.create(null);
+    function visit(value) {
+        if (!value || typeof value !== 'object')
+            return;
+        const ref = value.$ref;
+        if (ref) {
+            const name = ref.slice('#/$defs/'.length);
+            if (!Object.hasOwn(selected, name)) {
+                selected[name] = definitions[name];
+                visit(selected[name]);
+            }
+        }
+        for (const child of Object.values(value))
+            visit(child);
+    }
+    visit(schema);
+    return selected;
+}
+function record(value, target, label) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        fail('SOURCE_INVALID', `${label} must be an explicit record.`, target);
+    return value;
+}
+function identity(value, target) {
+    const id = value.id;
+    if (typeof id !== 'string' ||
+        !/^https:\/\/(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\/[a-z0-9._~-]+)+(?![\s\S])/.test(id) ||
+        id
+            .slice(8)
+            .split('/')
+            .slice(1)
+            .some((part) => part === '.' || part === '..') ||
+        isIpHost(id) ||
+        typeof value.version !== 'string' ||
+        !/^(?:0|[1-9][0-9]*)\.(?:0|[1-9][0-9]*)\.(?:0|[1-9][0-9]*)(?![\s\S])/.test(value.version))
+        fail('SOURCE_INVALID', 'Supply an exact FLOW HTTPS contract id and version together.', target);
+}
+function isIpHost(id) {
+    const labels = id.slice(8).split('/')[0].split('.');
+    return labels.length === 4 && labels.every((s) => /^[0-9]{1,3}$/.test(s) && Number(s) <= 255);
+}
+function expand(schema, definitions, origins, output) {
+    let count = 0;
+    function walk(s, depth) {
+        const origin = origins.get(s);
+        if (++count > 4096 || depth > 64)
+            fail('PROJECTION_LIMIT', 'Expanded projection exceeds its resource limits.', origin, output);
+        let result;
+        if (s.$ref) {
+            const { $ref, ...rest } = s;
+            const target = definitions[$ref.slice('#/$defs/'.length)];
+            if (!target)
+                fail('PROJECTION_INVALID', 'Unresolved projection definition.', origin, output);
+            result = { ...walk(target, depth + 1), ...rest };
+        }
+        else {
+            result = { ...s };
+            if (s.properties)
+                result.properties = Object.fromEntries(Object.entries(s.properties).map(([k, v]) => [k, walk(v, depth + 1)]));
+            if (s.items)
+                result.items = walk(s.items, depth + 1);
+            if (s.anyOf)
+                result.anyOf = s.anyOf.map((v) => walk(v, depth + 1));
+            if (s.oneOf)
+                result.oneOf = s.oneOf.map((v) => walk(v, depth + 1));
+        }
+        if (typeof result.const === 'string') {
+            const { const: literal, ...rest } = result;
+            result = { ...rest, type: 'string', enum: [literal] };
+        }
+        else if (result.enum?.every((v) => typeof v === 'string')) {
+            result = { ...result, type: 'string' };
+        }
+        if (result.anyOf?.length === 2) {
+            const nil = result.anyOf.find((v) => v.type === 'null' && Object.keys(v).length === 1);
+            const value = result.anyOf.find((v) => v !== nil);
+            if (nil && value && (value.type === 'string' || value.type === 'integer')) {
+                const { anyOf: _branches, ...rest } = result;
+                result = {
+                    ...value,
+                    ...rest,
+                    type: [value.type, 'null'],
+                    ...(value.enum ? { enum: [...value.enum, null] } : {}),
+                };
+            }
+        }
+        if (origin)
+            origins.set(result, origin);
+        return result;
+    }
+    return walk(schema, 1);
+}
+function checkAgent(root, origins, output) {
+    let properties = 0, enums = 0, characters = 0;
+    function walk(s, depth) {
+        const target = origins.get(s);
+        const reject = (why) => fail('AGENT_SCHEMA_UNSUPPORTED', why, target, output);
+        if (depth > 8)
+            reject('Agent schemas allow at most eight levels.');
+        const keys = new Set(['type', 'description']);
+        const baseType = Array.isArray(s.type) && s.type.length === 2 && s.type[1] === 'null' ? s.type[0] : s.type;
+        if (s.type === 'object') {
+            for (const k of ['properties', 'required', 'additionalProperties'])
+                keys.add(k);
+            const names = Object.keys(s.properties ?? {});
+            properties += names.length;
+            characters += names.reduce((n, k) => n + [...k].length, 0);
+            const optional = names.find((k) => !s.required?.includes(k));
+            if (optional)
+                fail('AGENT_SCHEMA_UNSUPPORTED', `Optional property "${optional}" is not supported by the Agent profile.`, origins.get(s.properties[optional]), output);
+            if (!names.length ||
+                names.length > 32 ||
+                properties > 128 ||
+                s.additionalProperties !== false ||
+                s.required?.length !== names.length ||
+                names.some((k) => !s.required?.includes(k))) {
+                reject('Agent objects require 1–32 properties, all required and closed (128 total).');
+            }
+            for (const child of Object.values(s.properties))
+                walk(child, depth + 1);
+        }
+        else if (s.type === 'array') {
+            for (const k of ['items', 'minItems', 'maxItems'])
+                keys.add(k);
+            if (!s.items || !Number.isSafeInteger(s.maxItems) || s.maxItems < 0 || s.maxItems > 256) {
+                reject('Agent arrays require maxItems between 0 and 256.');
+            }
+            walk(s.items, depth + 1);
+        }
+        else if (baseType === 'string') {
+            keys.add('enum');
+        }
+        else if (baseType !== 'integer') {
+            reject('This type or union is outside the qualified Agent projection profile.');
+        }
+        if (Object.keys(s).some((k) => !keys.has(k))) {
+            reject('A constraint cannot be represented in the Agent profile; it was not removed.');
+        }
+        if (s.enum) {
+            if (!s.enum.length ||
+                s.enum.some((v) => typeof v !== 'string' && !(v === null && Array.isArray(s.type))))
+                reject('Agent string enums must be nonempty string sets.');
+            enums += s.enum.length;
+            const chars = s.enum.reduce((n, v) => n + (typeof v === 'string' ? [...v].length : 0), 0);
+            characters += chars;
+            if (enums > 256 || (s.enum.length > 250 && chars > 15000))
+                reject('Agent enum limits exceeded.');
+        }
+        if (characters > 120000)
+            reject('Agent property/enum text limit exceeded.');
+    }
+    if (root.type !== 'object')
+        fail('AGENT_SCHEMA_UNSUPPORTED', 'An Agent projection needs a closed object root.', origins.get(root), output);
+    walk(root, 1);
+}
+function declarations(descriptor) {
+    function render(s) {
+        if (s.$ref)
+            return s.$ref.slice('#/$defs/'.length);
+        if (s.const !== undefined)
+            return JSON.stringify(s.const);
+        if (s.enum)
+            return s.enum.map((v) => JSON.stringify(v)).join(' | ');
+        if (s.anyOf || s.oneOf)
+            return (s.anyOf ?? s.oneOf).map((v) => `(${render(v)})`).join(' | ');
+        if (s.type === 'object')
+            return `{ ${Object.entries(s.properties ?? {})
+                .map(([k, v]) => `${JSON.stringify(k)}${s.required?.includes(k) ? '' : '?'}: ${render(v)};`)
+                .join(' ')} }`;
+        if (s.type === 'array')
+            return `Array<${render(s.items)}>`;
+        if (s.type === 'integer' || s.type === 'number')
+            return 'number';
+        if (['string', 'boolean', 'null'].includes(s.type))
+            return s.type;
+        throw new Error('The lowered schema cannot be represented.');
+    }
+    return ('// Generated from the lowered FLOW contract. Bounds and exact validation remain runtime checks.\n' +
+        Object.entries(descriptor.$defs)
+            .map(([k, v]) => `export type ${k} = ${render(v)};\n`)
+            .join('') +
+        `export type FlowInput = ${render(descriptor.input)};\nexport type FlowResult = ${render(descriptor.result)};\n`);
+}

package/libexec/authoring/node_modules/@jigging/flow-authoring/dist/toolchain.d.ts

@@ -0,0 +1,16 @@
+export interface Toolchain {
+    profile: 'flow-authoring-typespec/0';
+    tool: string;
+    compiler: '1.16.0';
+    digest: string;
+}
+export interface SourceHeader extends Toolchain {
+    types: boolean;
+}
+/** Identify installed trusted tool bytes, including the resolved dependency closure. */
+export declare function getToolchain(): Promise<Toolchain>;
+/** Return source with an explicit pin. This function never writes the source file. */
+export declare function stampSource(source: string, options: {
+    types: boolean;
+}): Promise<string>;
+export declare function readHeader(source: string, toolchain: Toolchain): SourceHeader;

package/libexec/authoring/node_modules/@jigging/flow-authoring/dist/toolchain.js

@@ -0,0 +1,124 @@
+import { createHash } from 'node:crypto';
+import { lstat, readdir, readFile, realpath } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { fail } from './errors.js';
+import { checkText } from './values.js';
+const prefix = '// flow-authoring: ';
+let cached;
+/** Identify installed trusted tool bytes, including the resolved dependency closure. */
+export function getToolchain() {
+    cached ??= fingerprint();
+    return cached;
+}
+async function fingerprint() {
+    const root = await realpath(fileURLToPath(new URL('..', import.meta.url)));
+    const hashes = new Map();
+    const roots = new Set();
+    let files = 0, bytes = 0;
+    async function file(path) {
+        if (++files > 20000)
+            fail('TOOLCHAIN_LIMIT', 'Installed toolchain has too many files.');
+        const data = await readFile(path);
+        bytes += data.length;
+        if (bytes > 134217728)
+            fail('TOOLCHAIN_LIMIT', 'Installed toolchain exceeds 128 MiB.');
+        return createHash('sha256').update(data).digest('hex');
+    }
+    async function walk(path, relative, hash) {
+        for (const entry of (await readdir(path, { withFileTypes: true })).sort((a, b) => a.name < b.name ? -1 : 1)) {
+            if (entry.name === 'node_modules')
+                continue;
+            const full = join(path, entry.name), name = relative + entry.name;
+            if (entry.isDirectory())
+                await walk(full, name + '/', hash);
+            else if (entry.isFile())
+                hash.update(JSON.stringify([name, await file(full)]));
+            else
+                fail('TOOLCHAIN_INVALID', 'Toolchain package contents must be regular files or directories.');
+        }
+    }
+    async function resolveDependency(from, name) {
+        let cursor = from;
+        for (;;) {
+            const candidate = join(cursor, 'node_modules', name);
+            try {
+                await lstat(join(candidate, 'package.json'));
+                return await realpath(candidate);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+            const parent = dirname(cursor);
+            if (parent === cursor)
+                fail('TOOLCHAIN_INVALID', `Install the declared toolchain dependency ${name}.`);
+            cursor = parent;
+        }
+    }
+    async function capture(path, own = false) {
+        const manifest = JSON.parse(await readFile(join(path, 'package.json'), 'utf8'));
+        const id = `${manifest.name}@${manifest.version}`;
+        if (roots.has(path))
+            return id;
+        roots.add(path);
+        const hash = createHash('sha256');
+        if (own) {
+            hash.update(await file(join(path, 'package.json')));
+            await walk(join(path, 'dist'), 'dist/', hash);
+        }
+        else
+            await walk(path, '', hash);
+        const digest = hash.digest('hex');
+        if (hashes.has(id) && hashes.get(id) !== digest)
+            fail('TOOLCHAIN_INVALID', 'Conflicting bytes for one dependency identity.');
+        hashes.set(id, digest);
+        for (const name of Object.keys(manifest.dependencies ?? {}).sort()) {
+            const dependency = await capture(await resolveDependency(path, name));
+            hashes.set(`${id} -> ${name}`, dependency);
+        }
+        return id;
+    }
+    const tool = await capture(root, true);
+    if (!hashes.has('@typespec/compiler@1.16.0'))
+        fail('TOOLCHAIN_INVALID', 'This profile requires TypeSpec 1.16.0.');
+    const digest = 'sha256:' +
+        createHash('sha256')
+            .update('FLOW-Authoring-Toolchain/0\0')
+            .update(JSON.stringify([...hashes].sort(([a], [b]) => (a < b ? -1 : 1))))
+            .digest('hex');
+    return Object.freeze({ profile: 'flow-authoring-typespec/0', tool, compiler: '1.16.0', digest });
+}
+/** Return source with an explicit pin. This function never writes the source file. */
+export async function stampSource(source, options) {
+    checkText(source, 65536);
+    if (typeof options.types !== 'boolean')
+        fail('SOURCE_INVALID', 'Choose whether to generate types.');
+    const newline = source.indexOf('\n');
+    const body = source.startsWith(prefix)
+        ? source.slice(newline < 0 ? source.length : newline + 1)
+        : source;
+    const header = { ...(await getToolchain()), types: options.types };
+    const result = prefix + JSON.stringify(header) + '\n' + body;
+    checkText(result, 65536);
+    return result;
+}
+export function readHeader(source, toolchain) {
+    checkText(source, 65536);
+    const first = source.split('\n', 1)[0];
+    if (!first.startsWith(prefix) || first.length > 2048) {
+        fail('SOURCE_HEADER', 'Use stampSource() to select this installed authoring profile explicitly.');
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(first.slice(prefix.length));
+    }
+    catch {
+        fail('SOURCE_HEADER', 'The authoring header is not valid JSON.');
+    }
+    const expected = { ...toolchain, types: parsed?.types };
+    if (typeof parsed?.types !== 'boolean' || first !== prefix + JSON.stringify(expected)) {
+        fail('SOURCE_HEADER', 'Header differs from the installed toolchain or canonical options; select the intended tool explicitly.');
+    }
+    return parsed;
+}

package/libexec/authoring/node_modules/@jigging/flow-authoring/dist/values.d.ts

@@ -0,0 +1,3 @@
+export declare function channelReference(path: string): boolean;
+export declare function checkText(text: string, maxBytes: number): void;
+export declare function encode(value: unknown): string;