@sanity/runtime-cli 17.16.0-app-functions.ge0a25ea → 17.16.0-next.g05d3b7f

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sanity/runtime-cli",
   "description": "Sanity's Runtime CLI for Blueprints and Functions",
-  "version": "17.16.0-app-functions.ge0a25ea",
+  "version": "17.16.0-next.g05d3b7f",
   "author": "Sanity Runtime Team",
   "type": "module",
   "license": "MIT",
@@ -14,26 +14,6 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
-    "./functions/stack": {
-      "types": "./dist/functions/stack.d.ts",
-      "import": "./dist/functions/stack.js",
-      "require": "./dist/functions/stack.js"
-    },
-    "./functions/contracts": {
-      "types": "./dist/functions/contracts.d.ts",
-      "import": "./dist/functions/contracts.js",
-      "require": "./dist/functions/contracts.js"
-    },
-    "./functions/deploy": {
-      "types": "./dist/functions/deploy.d.ts",
-      "import": "./dist/functions/deploy.js",
-      "require": "./dist/functions/deploy.js"
-    },
-    "./functions/build": {
-      "types": "./dist/functions/build.d.ts",
-      "import": "./dist/functions/build.js",
-      "require": "./dist/functions/build.js"
-    },
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
@@ -106,7 +86,6 @@
     "strip-ansi": "^7.2.0",
     "tar-fs": "^3.1.3",
     "tar-stream": "^3.2.1",
-    "typescript-compiler": "npm:typescript@^6.0.3",
     "vite": "^8.3.0",
     "ws": "^8.21.3",
     "xdg-basedir": "^5.1.0"
@@ -121,7 +100,7 @@
     "@oclif/test": "^4.2.0",
     "@playwright/test": "^1.63.0",
     "@sanity-labs/design-tokens": "^0.0.2-alpha.2",
-    "@sanity/functions": "^1.8.1",
+    "@sanity/functions": "^1.10.1",
     "@types/cardinal": "^2.1.1",
     "@types/mime-types": "^3.0.1",
     "@types/node": "^22",

package/dist/functions/artifacts.d.ts

@@ -1,13 +0,0 @@
-export declare const functionOutputFileName = "index.js";
-/** Metadata for a compiled function, resolved without loading its handler. */
-export interface FunctionBuild {
-    name: string;
-    src: string;
-    entryPoint: string;
-}
-/** Validate artifacts produced by buildFunction before packaging or deployment. */
-export declare function readFunctionBuild(options: {
-    name: string;
-    src: string;
-    workDir: string;
-}): Promise<FunctionBuild>;

package/dist/functions/artifacts.js

@@ -1,26 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import path from 'node:path';
-import { findFunctionEntryPoint } from '../utils/functions/find-entry-point.js';
-export const functionOutputFileName = 'index.js';
-/** Validate artifacts produced by buildFunction before packaging or deployment. */
-export async function readFunctionBuild(options) {
-    const { name, workDir } = options;
-    const src = path.resolve(workDir, options.src);
-    try {
-        const pkg = JSON.parse(await readFile(path.join(src, 'package.json'), 'utf8'));
-        if (!pkg ||
-            typeof pkg !== 'object' ||
-            !('main' in pkg) ||
-            pkg.main !== functionOutputFileName ||
-            !('type' in pkg) ||
-            pkg.type !== 'module')
-            throw new Error('The function package metadata does not match its build format.');
-        const entryPoint = await findFunctionEntryPoint(src, name);
-        if (entryPoint !== path.join(src, functionOutputFileName))
-            throw new Error(`The compiled entry ${functionOutputFileName} is missing.`);
-        return { name, src, entryPoint };
-    }
-    catch (error) {
-        throw new Error(`Function "${name}" is not built. Run sanity build first.`, { cause: error });
-    }
-}

package/dist/functions/build.d.ts

@@ -1,15 +0,0 @@
-import { type FunctionContract } from './contracts.js';
-export interface BuildFunctionOptions {
-    name: string;
-    contract?: FunctionContract;
-    /** Function directory or entry file, relative to workDir. */
-    src: string;
-    workDir: string;
-    /** Build output directory, relative to workDir. Its contents are replaced. */
-    outDir: string;
-}
-/** Build a standalone ESM function bundle without a blueprint, stack, or ZIP. */
-export declare function buildFunction({ name, src, workDir, outDir, contract, }: BuildFunctionOptions): Promise<{
-    outputDir: string;
-}>;
-export { type FunctionBuild, readFunctionBuild } from './artifacts.js';

package/dist/functions/build.js

@@ -1,27 +0,0 @@
-import path from 'node:path';
-import { findFunctionEntryPoint } from '../utils/functions/find-entry-point.js';
-import { transpileFunction } from '../utils/functions/transpile/function.js';
-import { functionOutputFileName } from './artifacts.js';
-import { functionContractPlugin } from './contractPlugin.js';
-import { generateFunctionContracts } from './contracts.js';
-/** Build a standalone ESM function bundle without a blueprint, stack, or ZIP. */
-export async function buildFunction({ name, src, workDir, outDir, contract, }) {
-    const functionPath = path.resolve(workDir, src);
-    const entryPoint = await findFunctionEntryPoint(functionPath, name);
-    const resolvedContract = contract ?? (await generateFunctionContracts({ workDir, functions: [{ name, src }] }))[0];
-    if (resolvedContract.entryPoint !== entryPoint || resolvedContract.name !== name)
-        throw new Error(`Function contract does not match "${name}".`);
-    const validation = functionContractPlugin(resolvedContract);
-    const result = await transpileFunction({
-        resource: { name, src, type: 'sanity.function.pubsub' },
-        functionPath,
-        entryPoint: validation.entryPoint,
-        plugins: [validation.plugin],
-        workDir,
-        outDir: path.resolve(workDir, outDir),
-        outputFileName: functionOutputFileName,
-        bundle: true,
-    });
-    return { outputDir: result.outputDir };
-}
-export { readFunctionBuild } from './artifacts.js';

package/dist/functions/contractPlugin.d.ts

@@ -1,7 +0,0 @@
-import type { Plugin } from 'vite';
-import type { FunctionContract } from './contracts.js';
-/** Build a validating PubSub entry around the original handler. */
-export declare function functionContractPlugin(contract: FunctionContract): {
-    entryPoint: string;
-    plugin: Plugin;
-};

package/dist/functions/contractPlugin.js

@@ -1,32 +0,0 @@
-import { jsonGuard, validatorSource } from './contracts/validation.js';
-/** Build a validating PubSub entry around the original handler. */
-export function functionContractPlugin(contract) {
-    const entryPoint = `virtual:sanity-function-contract:${contract.name}`;
-    const resolvedId = `\0${entryPoint}`;
-    const source = `import {handler as implementation} from ${JSON.stringify(contract.entryPoint.replaceAll('\\', '/'))}
-${jsonGuard}
-const validateInput = ${validatorSource(contract.input)}
-const validateOutput = ${validatorSource(contract.output)}
-export async function handler(envelope) {
-  let input = envelope?.event?.data
-  ${contract.input.kind === 'void' ? "if (input !== null && typeof input === 'object' && !Array.isArray(input) && Object.keys(input).length === 0) input = undefined" : ''}
-  if (!validateInput(input)) throw new TypeError(${JSON.stringify(`Invalid input for function "${contract.name}". Match its declared input type.`)})
-  const result = await implementation(envelope)
-  if (!validateOutput(result)) throw new TypeError(${JSON.stringify(`Function "${contract.name}" returned data that does not match its declared return type.`)})
-  return result
-}`;
-    return {
-        entryPoint,
-        plugin: {
-            name: 'sanity/function-contract',
-            resolveId(id) {
-                if (id === entryPoint)
-                    return resolvedId;
-            },
-            load(id) {
-                if (id === resolvedId)
-                    return source;
-            },
-        },
-    };
-}

package/dist/functions/contracts/schema.d.ts

@@ -1,22 +0,0 @@
-import ts from 'typescript-compiler';
-export type ContractSchema = {
-    kind: 'string' | 'number' | 'boolean' | 'null' | 'void' | 'never';
-} | {
-    kind: 'literal';
-    value: string | number | boolean;
-} | {
-    kind: 'array';
-    items: ContractSchema;
-} | {
-    kind: 'union';
-    variants: ContractSchema[];
-} | {
-    kind: 'object';
-    properties: Record<string, {
-        optional: boolean;
-        schema: ContractSchema;
-    }>;
-    additional?: ContractSchema;
-};
-export declare function schemaFromType(checker: ts.TypeChecker, type: ts.Type, location: string, allowVoid?: boolean, parents?: Set<ts.Type>): ContractSchema;
-export declare function contractType(schema: ContractSchema): string;

package/dist/functions/contracts/schema.js

@@ -1,99 +0,0 @@
-import ts from 'typescript-compiler';
-export function schemaFromType(checker, type, location, allowVoid = false, parents = new Set()) {
-    const fail = (reason) => {
-        throw new Error(`${location}: ${reason} (${checker.typeToString(type)}). Use a concrete JSON-compatible type.`);
-    };
-    const flags = type.flags;
-    if (flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.TypeParameter))
-        return fail('Unresolved or untyped contract');
-    if (flags & ts.TypeFlags.Never)
-        return { kind: 'never' };
-    if (flags & (ts.TypeFlags.Void | ts.TypeFlags.Undefined)) {
-        if (!allowVoid)
-            return fail('Undefined is only supported for optional object fields or a void result');
-        return { kind: 'void' };
-    }
-    if (flags & ts.TypeFlags.Null)
-        return { kind: 'null' };
-    if (flags & ts.TypeFlags.StringLiteral)
-        return { kind: 'literal', value: type.value };
-    if (flags & ts.TypeFlags.NumberLiteral)
-        return { kind: 'literal', value: type.value };
-    if (flags & ts.TypeFlags.BooleanLiteral)
-        return { kind: 'literal', value: checker.typeToString(type) === 'true' };
-    if (flags & ts.TypeFlags.String)
-        return { kind: 'string' };
-    if (flags & ts.TypeFlags.Number)
-        return { kind: 'number' };
-    if (flags & ts.TypeFlags.Boolean)
-        return { kind: 'boolean' };
-    if (parents.has(type) || parents.size > 64)
-        return fail('Recursive or excessively nested contract');
-    const next = new Set(parents).add(type);
-    if (type.isUnion())
-        return {
-            kind: 'union',
-            variants: type.types.map((item) => schemaFromType(checker, item, location, allowVoid, next)),
-        };
-    if (checker.isTupleType(type))
-        return fail('Tuple contracts are not supported; use an array');
-    if (checker.isArrayType(type)) {
-        const element = checker.getTypeArguments(type)[0];
-        return { kind: 'array', items: schemaFromType(checker, element, `${location}[]`, false, next) };
-    }
-    if (!(flags & (ts.TypeFlags.Object | ts.TypeFlags.Intersection)))
-        return fail('Unsupported contract');
-    if (type.getCallSignatures().length || type.getConstructSignatures().length)
-        return fail('Functions and constructors cannot cross the function boundary');
-    if (type
-        .getSymbol()
-        ?.getDeclarations()
-        ?.some((declaration) => ts.isClassDeclaration(declaration) || ts.isClassExpression(declaration)))
-        return fail('Class instances cannot cross the function boundary');
-    if (checker.getIndexTypeOfType(type, ts.IndexKind.Number))
-        return fail('Numeric index signatures are not supported; use an array or string-keyed record');
-    const properties = Object.create(null);
-    for (const property of checker.getPropertiesOfType(type)) {
-        const name = property.getName();
-        if (name.startsWith('__@'))
-            return fail('Symbol properties cannot cross the function boundary');
-        const declaration = property.valueDeclaration ?? property.declarations?.[0];
-        if (!declaration)
-            return fail(`Cannot resolve property ${name}`);
-        const propertyType = checker.getTypeOfSymbolAtLocation(property, declaration);
-        const optional = !!(property.flags & ts.SymbolFlags.Optional);
-        const members = optional
-            ? (propertyType.isUnion() ? propertyType.types : [propertyType]).filter((member) => !(member.flags & ts.TypeFlags.Undefined))
-            : [propertyType];
-        const schemas = members.map((member) => schemaFromType(checker, member, `${location}.${name}`, false, next));
-        properties[name] = {
-            optional,
-            schema: schemas.length === 0
-                ? { kind: 'never' }
-                : schemas.length === 1
-                    ? schemas[0]
-                    : { kind: 'union', variants: schemas },
-        };
-    }
-    const indexType = checker.getIndexTypeOfType(type, ts.IndexKind.String);
-    const additional = indexType
-        ? schemaFromType(checker, indexType, `${location}[key]`, false, next)
-        : undefined;
-    return { kind: 'object', properties, ...(additional ? { additional } : {}) };
-}
-export function contractType(schema) {
-    switch (schema.kind) {
-        case 'literal':
-            return JSON.stringify(schema.value);
-        case 'array':
-            return `(${contractType(schema.items)})[]`;
-        case 'union':
-            return schema.variants.map(contractType).join(' | ');
-        case 'object':
-            return `{${Object.entries(schema.properties)
-                .map(([name, property]) => `${JSON.stringify(name)}${property.optional ? '?' : ''}: ${contractType(property.schema)};`)
-                .join(' ')}${schema.additional ? `[key: string]: ${contractType(schema.additional)};` : ''}}`;
-        default:
-            return schema.kind;
-    }
-}

package/dist/functions/contracts/validation.d.ts

@@ -1,3 +0,0 @@
-import type { ContractSchema } from './schema.js';
-export declare const jsonGuard = "function isJson(value, seen = new WeakSet(), depth = 0) {\n  if (depth > 100) return false\n  if (value === undefined || value === null) return true\n  if (typeof value === 'string' || typeof value === 'boolean') return true\n  if (typeof value === 'number') return Number.isFinite(value)\n  if (typeof value !== 'object' || seen.has(value) || Object.getOwnPropertySymbols(value).length) return false\n  seen.add(value)\n  try {\n    if (Array.isArray(value)) {\n      if (Object.keys(value).length !== value.length) return false\n      for (let index = 0; index < value.length; index++) {\n        if (!Object.hasOwn(value, index) || value[index] === undefined || !isJson(value[index], seen, depth + 1)) return false\n      }\n      return true\n    }\n    const prototype = Object.getPrototypeOf(value)\n    return (prototype === Object.prototype || prototype === null) && Object.values(value).every(item => isJson(item, seen, depth + 1))\n  } finally { seen.delete(value) }\n}";
-export declare function validatorSource(schema: ContractSchema): string;

package/dist/functions/contracts/validation.js

@@ -1,66 +0,0 @@
-// Self-contained code emitted into browser contracts and function bundles.
-export const jsonGuard = `function isJson(value, seen = new WeakSet(), depth = 0) {
-  if (depth > 100) return false
-  if (value === undefined || value === null) return true
-  if (typeof value === 'string' || typeof value === 'boolean') return true
-  if (typeof value === 'number') return Number.isFinite(value)
-  if (typeof value !== 'object' || seen.has(value) || Object.getOwnPropertySymbols(value).length) return false
-  seen.add(value)
-  try {
-    if (Array.isArray(value)) {
-      if (Object.keys(value).length !== value.length) return false
-      for (let index = 0; index < value.length; index++) {
-        if (!Object.hasOwn(value, index) || value[index] === undefined || !isJson(value[index], seen, depth + 1)) return false
-      }
-      return true
-    }
-    const prototype = Object.getPrototypeOf(value)
-    return (prototype === Object.prototype || prototype === null) && Object.values(value).every(item => isJson(item, seen, depth + 1))
-  } finally { seen.delete(value) }
-}`;
-export function validatorSource(schema) {
-    return `(value) => isJson(value) && (${validationExpression(schema, 'value')})`;
-}
-function validationExpression(schema, value, depth = 0) {
-    switch (schema.kind) {
-        case 'void':
-            return `${value} === undefined`;
-        case 'never':
-            return 'false';
-        case 'null':
-            return `${value} === null`;
-        case 'literal':
-            return `${value} === ${JSON.stringify(schema.value)}`;
-        case 'number':
-            return `(typeof ${value} === 'number' && Number.isFinite(${value}))`;
-        case 'string':
-        case 'boolean':
-            return `typeof ${value} === '${schema.kind}'`;
-        case 'union':
-            return `(${schema.variants.map((item) => `(${validationExpression(item, value, depth + 1)})`).join(' || ')})`;
-        case 'array': {
-            const item = `item${depth}`;
-            return `(Array.isArray(${value}) && ${value}.every(${item} => ${validationExpression(schema.items, item, depth + 1)}))`;
-        }
-        case 'object': {
-            const checks = [
-                `${value} !== null`,
-                `typeof ${value} === 'object'`,
-                `!Array.isArray(${value})`,
-            ];
-            for (const [name, property] of Object.entries(schema.properties)) {
-                const member = `${value}[${JSON.stringify(name)}]`;
-                const present = `Object.hasOwn(${value}, ${JSON.stringify(name)})`;
-                const check = validationExpression(property.schema, member, depth + 1);
-                checks.push(property.optional
-                    ? `(!${present} || ${member} === undefined || (${check}))`
-                    : `(${present} && (${check}))`);
-            }
-            if (schema.additional) {
-                const key = `key${depth}`;
-                checks.push(`Object.keys(${value}).every(${key} => ${JSON.stringify(Object.keys(schema.properties))}.includes(${key}) || (${validationExpression(schema.additional, `${value}[${key}]`, depth + 1)}))`);
-            }
-            return `(${checks.join(' && ')})`;
-        }
-    }
-}

package/dist/functions/contracts.d.ts

@@ -1,20 +0,0 @@
-import { type ContractSchema } from './contracts/schema.js';
-export interface FunctionContract {
-    name: string;
-    src: string;
-    entryPoint: string;
-    input: ContractSchema;
-    output: ContractSchema;
-}
-/** Discover input and output types without loading or executing function code. */
-export declare function generateFunctionContracts(options: {
-    workDir: string;
-    functions: {
-        name: string;
-        src: string;
-    }[];
-}): Promise<FunctionContract[]>;
-/** Check app consumers after regenerating their function registry. */
-export declare function checkFunctionTypes(workDir: string): void;
-/** Emit a standalone declaration registry and browser-safe validators. */
-export declare function writeFunctionContracts(workDir: string, contracts: FunctionContract[]): Promise<void>;

package/dist/functions/contracts.js

@@ -1,119 +0,0 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-import ts from 'typescript-compiler';
-import { findFunctionEntryPoint } from '../utils/functions/find-entry-point.js';
-import { contractType, schemaFromType } from './contracts/schema.js';
-import { jsonGuard, validatorSource } from './contracts/validation.js';
-/** Discover input and output types without loading or executing function code. */
-export async function generateFunctionContracts(options) {
-    const entries = await Promise.all(options.functions.map(async (fn) => ({
-        ...fn,
-        entryPoint: await findFunctionEntryPoint(path.resolve(options.workDir, fn.src), fn.name),
-    })));
-    const config = readProjectConfig(options.workDir);
-    const program = ts.createProgram(entries.map((fn) => fn.entryPoint), {
-        target: ts.ScriptTarget.ESNext,
-        module: ts.ModuleKind.ESNext,
-        moduleResolution: ts.ModuleResolutionKind.Bundler,
-        ...config?.options,
-        allowJs: true,
-        checkJs: true,
-        noEmit: true,
-        strict: true,
-        strictNullChecks: true,
-        skipLibCheck: true,
-        composite: false,
-        incremental: false,
-        declaration: false,
-        declarationMap: false,
-        tsBuildInfoFile: undefined,
-    });
-    assertDiagnostics(ts.getPreEmitDiagnostics(program), options.workDir);
-    const checker = program.getTypeChecker();
-    return entries.map((fn) => readContract(checker, program, fn));
-}
-/** Check app consumers after regenerating their function registry. */
-export function checkFunctionTypes(workDir) {
-    const config = readProjectConfig(workDir);
-    if (!config)
-        return;
-    const program = ts.createProgram({
-        rootNames: config.fileNames,
-        options: { ...config.options, noEmit: true, incremental: false, tsBuildInfoFile: undefined },
-        projectReferences: config.projectReferences,
-    });
-    assertDiagnostics(ts.getPreEmitDiagnostics(program), workDir);
-}
-function readProjectConfig(workDir) {
-    const configPath = ts.findConfigFile(workDir, ts.sys.fileExists);
-    if (!configPath)
-        return undefined;
-    const config = ts.readConfigFile(configPath, ts.sys.readFile);
-    if (config.error)
-        assertDiagnostics([config.error], workDir);
-    const parsed = ts.parseJsonConfigFileContent(config.config, ts.sys, path.dirname(configPath));
-    assertDiagnostics(parsed.errors, workDir);
-    return parsed;
-}
-function assertDiagnostics(diagnostics, workDir) {
-    const errors = diagnostics.filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error);
-    if (errors.length)
-        throw new Error(ts.formatDiagnostics(errors, {
-            getCanonicalFileName: (file) => file,
-            getCurrentDirectory: () => workDir,
-            getNewLine: () => '\n',
-        }));
-}
-function readContract(checker, program, fn) {
-    const source = program.getSourceFile(fn.entryPoint);
-    const module = source && checker.getSymbolAtLocation(source);
-    const exported = module && checker.getExportsOfModule(module).find((item) => item.getName() === 'handler');
-    if (!source || !exported)
-        throw new Error(`Function "${fn.name}" must export handler.`);
-    const signatures = checker.getTypeOfSymbolAtLocation(exported, source).getCallSignatures();
-    if (signatures.length !== 1)
-        throw new Error(`Function "${fn.name}" must have one handler signature.`);
-    const signature = signatures[0];
-    if (signature.parameters.length > 1)
-        throw new Error(`Function "${fn.name}" must accept a single FunctionArgs envelope.`);
-    let input = { kind: 'void' };
-    const parameter = signature.parameters[0];
-    if (parameter) {
-        const args = checker.getTypeOfSymbolAtLocation(parameter, source);
-        const event = args.getProperty('event');
-        const eventType = event && checker.getTypeOfSymbolAtLocation(event, source);
-        const data = eventType?.getProperty('data');
-        if (!data)
-            throw new Error(`Function "${fn.name}" must annotate its input with FunctionArgs<Input>.`);
-        input = schemaFromType(checker, checker.getTypeOfSymbolAtLocation(data, source), `${fn.name} input`, true);
-    }
-    const isObjectInput = (schema) => schema.kind === 'object' || (schema.kind === 'union' && schema.variants.every(isObjectInput));
-    if (input.kind !== 'void' && !isObjectInput(input))
-        throw new Error(`Function "${fn.name}" input must be a JSON object or omitted. Put scalar values inside an input object.`);
-    const returnType = checker.getReturnTypeOfSignature(signature);
-    const output = schemaFromType(checker, checker.getAwaitedType(returnType) ?? returnType, `${fn.name} output`, true);
-    return { ...fn, input, output };
-}
-const generatedHeader = '// Generated by Sanity CLI. Do not edit.\n';
-/** Emit a standalone declaration registry and browser-safe validators. */
-export async function writeFunctionContracts(workDir, contracts) {
-    const declarations = `${generatedHeader}import '@sanity/sdk'\n\ndeclare module '@sanity/sdk' {\n  interface AppFunctionRegistry {\n${contracts.map((fn) => `    ${JSON.stringify(fn.name)}: {input: ${contractType(fn.input)}; output: ${contractType(fn.output)}}`).join('\n')}\n  }\n}\n`;
-    const client = `${generatedHeader}${jsonGuard}\nexport const functionContracts = Object.fromEntries([\n${contracts.map((fn) => `[${JSON.stringify(fn.name)}, {hasInput: ${fn.input.kind !== 'void'}, validateInput: ${validatorSource(fn.input)}, validateOutput: ${validatorSource(fn.output)}}]`).join(',\n')}\n])\n`;
-    await writeGenerated(path.join(workDir, 'sanity.functions.d.ts'), declarations);
-    await writeGenerated(path.join(workDir, '.sanity', 'function-contracts.js'), client);
-}
-async function writeGenerated(file, content) {
-    try {
-        const previous = await readFile(file, 'utf8');
-        if (!previous.startsWith(generatedHeader))
-            throw new Error(`Refusing to overwrite non-generated file ${file}. Move it before generating function contracts.`);
-        if (previous === content)
-            return;
-    }
-    catch (error) {
-        if (!(error instanceof Error && 'code' in error && error.code === 'ENOENT'))
-            throw error;
-    }
-    await mkdir(path.dirname(file), { recursive: true });
-    await writeFile(file, content);
-}

package/dist/functions/deploy.d.ts

@@ -1,15 +0,0 @@
-import type { CoreResult } from '../cores/index.js';
-/** Deploy already-built PubSub functions to an app-owned organization stack. */
-export declare function deployFunctions(options: {
-    appId: string;
-    organizationId: string;
-    stackId: string;
-    workDir: string;
-    functions: {
-        name: string;
-        src: string;
-    }[];
-    token: string;
-    fetchFn: typeof fetch;
-    log: (message: string) => void;
-}): Promise<CoreResult>;

package/dist/functions/deploy.js

@@ -1,60 +0,0 @@
-import { getStack } from '../actions/blueprints/stacks.js';
-import { deployResourcesCore } from '../cores/blueprints/deploy.js';
-import { Logger } from '../utils/logger.js';
-import { readFunctionBuild } from './artifacts.js';
-import { assertAppFunctionStack } from './stack.js';
-/** Deploy already-built PubSub functions to an app-owned organization stack. */
-export async function deployFunctions(options) {
-    const { organizationId, stackId, workDir, fetchFn } = options;
-    const auth = {
-        token: options.token,
-        scopeType: 'organization',
-        scopeId: organizationId,
-    };
-    const result = await getStack({ stackId, auth, fetchFn });
-    if (!result.ok)
-        return { success: false, error: result.error || 'Could not read app function stack' };
-    const stack = result.stack;
-    try {
-        assertAppFunctionStack(stack, options);
-    }
-    catch (error) {
-        return { success: false, error: error instanceof Error ? error.message : String(error) };
-    }
-    if (stack.resources.some((resource) => resource.type !== 'sanity.function.pubsub')) {
-        return {
-            success: false,
-            error: 'The app function stack contains other resource types. Use a dedicated app function stack.',
-        };
-    }
-    const resources = [];
-    for (const fn of options.functions) {
-        let src;
-        try {
-            src = (await readFunctionBuild({ ...fn, workDir })).src;
-        }
-        catch (error) {
-            return { success: false, error: error instanceof Error ? error.message : String(error) };
-        }
-        resources.push({
-            name: fn.name,
-            type: 'sanity.function.pubsub',
-            src,
-            transpile: false,
-            autoResolveDeps: false,
-        });
-    }
-    return deployResourcesCore({
-        auth,
-        stackId,
-        scopeType: 'organization',
-        scopeId: organizationId,
-        deployedStack: stack,
-        resources,
-        workDir,
-        fetchFn,
-        bin: 'sanity',
-        flags: {},
-        log: Logger(options.log, { json: true }),
-    });
-}

package/dist/functions/stack.d.ts

@@ -1,18 +0,0 @@
-import type { Stack, StackSummary } from '../utils/types.js';
-interface AppFunctionIdentity {
-    appId: string;
-    organizationId: string;
-}
-/** Shared ownership check for provisioning and deploying an app's function stack. */
-export declare function assertAppFunctionStack(stack: Stack | StackSummary, { appId, organizationId }: AppFunctionIdentity): void;
-/** Resolve or create a dedicated app stack using the Blueprint stack operations. */
-export declare function ensureFunctionStack(options: AppFunctionIdentity & {
-    token: string;
-    fetchFn: typeof fetch;
-    stackId?: string;
-    dryRun?: boolean;
-}): Promise<{
-    created: boolean;
-    id: string;
-} | null>;
-export { BLUEPRINTS_API_VERSION } from '../config.js';