solve-engine 1.0.2 → 1.1.1

package/dist/index.d.cts

@@ -1,92 +1,128 @@
-import { I as IEnginePackage } from './PackageRegistry-zuzqt51V.cjs';
-export { E as EvalResults, a as ExpressionEngine, b as IPackageRegistry, L as LineEvaluation, P as PackageRegistry, p as packageRegistry } from './PackageRegistry-zuzqt51V.cjs';
+import { I as IEnginePackage } from './PackageRegistry-BHWJP83F.cjs';
+export { a as EngineRestoreOptions, b as EngineSnapshot, c as EvalResults, d as Explanation, e as ExplanationStep, E as ExpressionEngine, f as IPackageRegistry, L as LineEvaluation, P as PackageRegistry, S as SNAPSHOT_FORMAT, g as SNAPSHOT_VERSION, h as SerializedAnonymousBody, i as SerializedBytecode, j as SerializedDecimal, k as SerializedLineCacheEntry, l as SerializedNumber, m as SerializedRational, n as SerializedUserFunction, o as SerializedValue, p as SnapshotErrorCodes, q as packageRegistry } from './PackageRegistry-BHWJP83F.cjs';
+export { a as CompatibilityConflict, b as CompatibilityConflictKind, C as CompatibilityReport, c as CompatibilitySeverity, d as checkPackageCompatibility } from './PackageCompatibility-B-7rK1TD.cjs';
 export { ENGINE_VERSION } from './constants.cjs';
-import './Parselet-DuI1Pjiq.cjs';
-import './BytecodeBuilder-B0xskcv5.cjs';
-import './Token-BzG5G4ja.cjs';
-import './pipeline-BEb3hujr.cjs';
-import './Value-CXJqDH9J.cjs';
+import './Parselet-BHcgK9S7.cjs';
+import './BytecodeBuilder-Bp9xeTmX.cjs';
+import './Token-B1hdkedD.cjs';
+import './pipeline-CtfJtPQc.cjs';
+import './Value-BUi1RA3S.cjs';
 import './variables.cjs';
-import './Lexer-DpjdaQ98.cjs';
+import './Lexer-BOs7euZe.cjs';
 import './resolvers.cjs';
 import '@tanstack/query-core';
-import './TokenNormalizer-DGVa24Q-.cjs';
-import './ScopeManager-B6GzdhVG.cjs';
-import './EngineError-LU7W7AgI.cjs';
-import './Configuration-B-G5gTRn.cjs';
+import './TokenNormalizer-DRc1Js1V.cjs';
+import './ScopeManager-8vf02dwj.cjs';
+import './EngineError-B61GS1jp.cjs';
+import './Configuration-C9W8tJv_.cjs';
 
 /**
- * Package load-time compatibility checking, the "detect overlapping
- * logic between packages" SDK surface.
+ * A higher-level, declarative way to contribute a single `name(args)`
+ * function, sitting ON TOP OF the package contract rather than replacing it.
  *
- * This engine's package system (`IEnginePackage`) has always had SOME
- * collision visibility, but it's inconsistent and scattered: `ParseletRegistry`
- * warns on a token-type overwrite, `asConverterRegistry` warns on a converter
- * name overwrite, and `PhraseTrie` warns on... nothing at all, a second
- * package fusing the exact same multi-word phrase to a different token type
- * silently wins with zero signal, the same class of gap
- * `ParseletRegistry.registerPrefix()`'s collision-visibility fix closed for
- * parselets specifically (see `ARCHITECTURE.md`'s punch list). And none of
- * these existing checks can be run BEFORE registration, they only fire at
- * the moment a collision actually happens, deep inside a live engine.
- *
- * `checkPackageCompatibility()` is a single, pure, side-effect-free function
- * that statically compares one candidate package's declared descriptor
- * against a list of already-registered packages' descriptors, across every
- * collision-capable field `IEnginePackage` has, callable standalone (a host
- * building a plugin marketplace could run it before ever constructing an
- * engine) or wired into registration itself (see
- * `ExpressionEngine.registerPackage()`, which calls this automatically and
- * logs every conflict found, the "load-up resiliency" half of this
- * mechanism).
- *
- * A real, concrete motivating bug (found the same session this module was
- * built): the currency package's real `IEnginePackage` descriptor
- * (`CurrencyPackage.ts`) and its parallel test-harness registration helper
- * (`parselets/index.ts`'s `registerCurrencyParselets()`) drifted out of sync
- *, new currency-symbol token types were wired into one but not the other
- * caught only by a test happening to exercise the stale path. This module
- * doesn't catch THAT specific class of bug (two hand-written registration
- * functions for the same logical package diverging is a source-consistency
- * problem, not a runtime collision), but it DOES catch the more common and
- * more dangerous sibling: two DIFFERENT, independently-authored packages
- * unknowingly claiming the same token type, phrase, converter name, plugin
- * function index, or lexer keyword.
+ * The low-level contract (allocate a plugin function index, write a parselet,
+ * emit `CALL_PLUGIN`) stays exactly as it was and remains the way to add
+ * anything that needs custom parsing. This module derives that same wiring
+ * from a declaration for the common case, a function called with parenthesised
+ * arguments, so adding `vat(x)` costs a spec object rather than an
+ * understanding of the parser and the VM. See `defineFunction`.
  */
-/** How serious a detected conflict is. */
-type CompatibilitySeverity = "error" | "warning" | "info";
-/** The category of overlap detected between two packages. */
-type CompatibilityConflictKind = "prefixParseletTokenType" | "infixParseletTokenType" | "phrase" | "converterName" | "pluginFunctionIndex" | "lexerKeyword" | "lexerOperator" | "asyncResolverNamespace" | "tokenCategory";
-/** One way two packages collide, for example claiming the same keyword. */
-interface CompatibilityConflict {
-    kind: CompatibilityConflictKind;
-    severity: CompatibilitySeverity;
-    /** Human-readable description, safe to log directly. */
-    detail: string;
-    /** The two package names involved, [existing, candidate]. */
-    packages: [string, string];
+/** The value types a declared argument or return may take. */
+type FunctionValueType = "number" | "string" | "boolean";
+/** The JavaScript type a {@link FunctionValueType} maps to at the `call` boundary. */
+type JsValue<T extends FunctionValueType> = T extends "number" ? number : T extends "string" ? string : boolean;
+/** One declared parameter: a name (for error messages) and a value type. */
+interface FunctionArg {
+    /** Parameter name, used only in the generated type-mismatch messages. */
+    name: string;
+    /** The value type this parameter accepts. */
+    type: FunctionValueType;
 }
-/** Every conflict found between a candidate package and those already registered. */
-interface CompatibilityReport {
-    /** `false` iff at least one "error"-severity conflict was found. */
-    compatible: boolean;
-    conflicts: CompatibilityConflict[];
+/** Map a tuple of {@link FunctionArg} specs to the tuple of JS values `call` receives. */
+type CallArgs<A extends readonly FunctionArg[]> = {
+    [K in keyof A]: JsValue<A[K]["type"]>;
+};
+/**
+ * A declarative function definition.
+ *
+ * `A` and `R` are inferred from the literal `args`/`returns` (via
+ * `defineFunction`'s `const` type parameter), so `call`'s parameters and
+ * return are typed from the declaration with no annotations: an
+ * `{ type: "number" }` argument arrives as a `number`, and a `returns:
+ * "string"` demands a `string` back.
+ */
+interface FunctionSpec<A extends readonly FunctionArg[] = readonly FunctionArg[], R extends FunctionValueType = FunctionValueType> {
+    /**
+     * The call name, a single identifier (`/^[a-z_][a-z0-9_]*$/i`). Registered
+     * as a lexer keyword, so it is matched case-insensitively and cannot collide
+     * with a built-in keyword (that collision throws at registration time).
+     */
+    name: string;
+    /** The parameters, in order. A fixed-length list: variadic and optional args are out of scope (see {@link defineFunction}). */
+    args: A;
+    /** The value type the function returns. */
+    returns: R;
+    /** The implementation, receiving plain JS values and returning one. Must be synchronous (see {@link defineFunction}). */
+    call: (...args: CallArgs<A>) => JsValue<R>;
 }
 /**
- * Statically check `candidate` against every package in `existing` for
- * overlapping/conflicting declarations, across every collision-capable
- * field `IEnginePackage` has. Pure and side-effect-free, does not touch
- * any shared registry, does not require a live `ExpressionEngine`.
+ * Error codes the declarative function API raises. Kept as a co-located const
+ * (the convention `errors/ErrorCode.ts` documents for a domain's own codes) so
+ * the strings have one source of truth.
+ */
+declare const DefineFunctionErrorCodes: {
+    /** The spec's `name` is not a single identifier. Thrown by `defineFunction`, before any engine sees it. */
+    readonly DEFINE_FUNCTION_INVALID_NAME: "DEFINE_FUNCTION_INVALID_NAME";
+    /** The spec is otherwise malformed (bad `args`, unsupported type, missing `call`). Thrown by `defineFunction`. */
+    readonly DEFINE_FUNCTION_INVALID_SPEC: "DEFINE_FUNCTION_INVALID_SPEC";
+    /** The call site passed the wrong number of arguments. Raised at evaluation time. */
+    readonly DEFINE_FUNCTION_ARITY_MISMATCH: "DEFINE_FUNCTION_ARITY_MISMATCH";
+    /** An argument was the wrong value type. Raised at evaluation time. */
+    readonly DEFINE_FUNCTION_ARGUMENT_TYPE: "DEFINE_FUNCTION_ARGUMENT_TYPE";
+    /** The `call` implementation returned a value that did not match `returns`. Raised at evaluation time, an authoring bug rather than a user one. */
+    readonly DEFINE_FUNCTION_RETURN_TYPE: "DEFINE_FUNCTION_RETURN_TYPE";
+};
+/**
+ * Turn a declarative {@link FunctionSpec} into a ready-to-register
+ * {@link IEnginePackage}.
+ *
+ * This is the higher-level API from issue #102. It derives, from the
+ * declaration alone, everything the low-level contract asks an author to write
+ * by hand: a plugin function index ({@link allocatePluginFunctionIndex}), a
+ * lexer keyword so the name tokenises, a call-syntax parselet emitting
+ * `CALL_PLUGIN`, and a handler that checks arity and argument types (yielding
+ * the engine's own structured errors) before invoking `call` and wrapping its
+ * result. Anything needing custom parsing keeps writing a raw parselet exactly
+ * as before, this sits on top of that contract and does not change it.
  *
  * @example
  * ```ts
- * const report = checkPackageCompatibility(myNewPackage, BUILTIN_PACKAGES);
- * if (!report.compatible) {
- *   for (const c of report.conflicts) console.error(c.detail);
- * }
+ * const engine = new ExpressionEngine("en", false, undefined, undefined, [
+ *   ...BUILTIN_PACKAGES,
+ *   defineFunction({
+ *     name: "vat",
+ *     args: [{ name: "amount", type: "number" }],
+ *     returns: "number",
+ *     call: (amount) => amount * 1.2,
+ *   }),
+ * ]);
+ * engine.evaluateExpression("vat(100)"); // 120
  * ```
+ *
+ * The returned package is self-contained and composes with any others through
+ * the engine's `packages` array; register several functions by passing several
+ * packages. Its name is `solve-fn-<name>`.
+ *
+ * Scope: arguments are a fixed-length list of `number`/`string`/`boolean`, and
+ * `call` is synchronous. Variadic and optional arguments, other value types
+ * (units, percentages, dates, matrices), and async work are deliberately out
+ * of scope, a function needing any of those keeps using the low-level
+ * contract, whose parselets and async resolvers are unchanged.
+ *
+ * @throws {EngineError} (category CONFIG) if the spec is malformed, at the
+ * point `defineFunction` is called, before the package reaches an engine.
  */
-declare function checkPackageCompatibility(candidate: IEnginePackage, existing: IEnginePackage[]): CompatibilityReport;
+declare function defineFunction<const A extends readonly FunctionArg[], R extends FunctionValueType>(spec: FunctionSpec<A, R>): IEnginePackage;
 
 /**
  * Engine-version package compatibility gating, the "reject a package built
@@ -149,4 +185,4 @@ declare function checkEngineVersionCompatibility(pkg: IEnginePackage, engineVers
  */
 declare function assertEngineVersionCompatible(pkg: IEnginePackage, engineVersion?: string): void;
 
-export { type CompatibilityConflict, type CompatibilityConflictKind, type CompatibilityReport, type CompatibilitySeverity, type EngineVersionCheckResult, IEnginePackage, assertEngineVersionCompatible, checkEngineVersionCompatibility, checkPackageCompatibility };
+export { DefineFunctionErrorCodes, type EngineVersionCheckResult, type FunctionArg, type FunctionSpec, type FunctionValueType, IEnginePackage, assertEngineVersionCompatible, checkEngineVersionCompatibility, defineFunction };

package/dist/index.d.ts

@@ -1,92 +1,128 @@
-import { I as IEnginePackage } from './PackageRegistry-ClIFXxAe.js';
-export { E as EvalResults, a as ExpressionEngine, b as IPackageRegistry, L as LineEvaluation, P as PackageRegistry, p as packageRegistry } from './PackageRegistry-ClIFXxAe.js';
+import { I as IEnginePackage } from './PackageRegistry-_8rDlvxI.js';
+export { a as EngineRestoreOptions, b as EngineSnapshot, c as EvalResults, d as Explanation, e as ExplanationStep, E as ExpressionEngine, f as IPackageRegistry, L as LineEvaluation, P as PackageRegistry, S as SNAPSHOT_FORMAT, g as SNAPSHOT_VERSION, h as SerializedAnonymousBody, i as SerializedBytecode, j as SerializedDecimal, k as SerializedLineCacheEntry, l as SerializedNumber, m as SerializedRational, n as SerializedUserFunction, o as SerializedValue, p as SnapshotErrorCodes, q as packageRegistry } from './PackageRegistry-_8rDlvxI.js';
+export { a as CompatibilityConflict, b as CompatibilityConflictKind, C as CompatibilityReport, c as CompatibilitySeverity, d as checkPackageCompatibility } from './PackageCompatibility-Dh59eF-X.js';
 export { ENGINE_VERSION } from './constants.js';
-import './Parselet-BaySkMV3.js';
-import './BytecodeBuilder-B0xskcv5.js';
-import './Token-BzG5G4ja.js';
-import './pipeline-B6k5lCB7.js';
-import './Value-CXJqDH9J.js';
+import './Parselet-BBT8riYh.js';
+import './BytecodeBuilder-Bp9xeTmX.js';
+import './Token-B1hdkedD.js';
+import './pipeline-DCd5M6Gk.js';
+import './Value-BUi1RA3S.js';
 import './variables.js';
-import './Lexer-CNmWxabg.js';
+import './Lexer-CSI_lwbW.js';
 import './resolvers.js';
 import '@tanstack/query-core';
-import './TokenNormalizer-t_GotBxr.js';
-import './ScopeManager-udv4Twwq.js';
-import './EngineError-LU7W7AgI.js';
-import './Configuration-B-G5gTRn.js';
+import './TokenNormalizer-C6VzZgHa.js';
+import './ScopeManager-CxA24W5n.js';
+import './EngineError-B61GS1jp.js';
+import './Configuration-C9W8tJv_.js';
 
 /**
- * Package load-time compatibility checking, the "detect overlapping
- * logic between packages" SDK surface.
+ * A higher-level, declarative way to contribute a single `name(args)`
+ * function, sitting ON TOP OF the package contract rather than replacing it.
  *
- * This engine's package system (`IEnginePackage`) has always had SOME
- * collision visibility, but it's inconsistent and scattered: `ParseletRegistry`
- * warns on a token-type overwrite, `asConverterRegistry` warns on a converter
- * name overwrite, and `PhraseTrie` warns on... nothing at all, a second
- * package fusing the exact same multi-word phrase to a different token type
- * silently wins with zero signal, the same class of gap
- * `ParseletRegistry.registerPrefix()`'s collision-visibility fix closed for
- * parselets specifically (see `ARCHITECTURE.md`'s punch list). And none of
- * these existing checks can be run BEFORE registration, they only fire at
- * the moment a collision actually happens, deep inside a live engine.
- *
- * `checkPackageCompatibility()` is a single, pure, side-effect-free function
- * that statically compares one candidate package's declared descriptor
- * against a list of already-registered packages' descriptors, across every
- * collision-capable field `IEnginePackage` has, callable standalone (a host
- * building a plugin marketplace could run it before ever constructing an
- * engine) or wired into registration itself (see
- * `ExpressionEngine.registerPackage()`, which calls this automatically and
- * logs every conflict found, the "load-up resiliency" half of this
- * mechanism).
- *
- * A real, concrete motivating bug (found the same session this module was
- * built): the currency package's real `IEnginePackage` descriptor
- * (`CurrencyPackage.ts`) and its parallel test-harness registration helper
- * (`parselets/index.ts`'s `registerCurrencyParselets()`) drifted out of sync
- *, new currency-symbol token types were wired into one but not the other
- * caught only by a test happening to exercise the stale path. This module
- * doesn't catch THAT specific class of bug (two hand-written registration
- * functions for the same logical package diverging is a source-consistency
- * problem, not a runtime collision), but it DOES catch the more common and
- * more dangerous sibling: two DIFFERENT, independently-authored packages
- * unknowingly claiming the same token type, phrase, converter name, plugin
- * function index, or lexer keyword.
+ * The low-level contract (allocate a plugin function index, write a parselet,
+ * emit `CALL_PLUGIN`) stays exactly as it was and remains the way to add
+ * anything that needs custom parsing. This module derives that same wiring
+ * from a declaration for the common case, a function called with parenthesised
+ * arguments, so adding `vat(x)` costs a spec object rather than an
+ * understanding of the parser and the VM. See `defineFunction`.
  */
-/** How serious a detected conflict is. */
-type CompatibilitySeverity = "error" | "warning" | "info";
-/** The category of overlap detected between two packages. */
-type CompatibilityConflictKind = "prefixParseletTokenType" | "infixParseletTokenType" | "phrase" | "converterName" | "pluginFunctionIndex" | "lexerKeyword" | "lexerOperator" | "asyncResolverNamespace" | "tokenCategory";
-/** One way two packages collide, for example claiming the same keyword. */
-interface CompatibilityConflict {
-    kind: CompatibilityConflictKind;
-    severity: CompatibilitySeverity;
-    /** Human-readable description, safe to log directly. */
-    detail: string;
-    /** The two package names involved, [existing, candidate]. */
-    packages: [string, string];
+/** The value types a declared argument or return may take. */
+type FunctionValueType = "number" | "string" | "boolean";
+/** The JavaScript type a {@link FunctionValueType} maps to at the `call` boundary. */
+type JsValue<T extends FunctionValueType> = T extends "number" ? number : T extends "string" ? string : boolean;
+/** One declared parameter: a name (for error messages) and a value type. */
+interface FunctionArg {
+    /** Parameter name, used only in the generated type-mismatch messages. */
+    name: string;
+    /** The value type this parameter accepts. */
+    type: FunctionValueType;
 }
-/** Every conflict found between a candidate package and those already registered. */
-interface CompatibilityReport {
-    /** `false` iff at least one "error"-severity conflict was found. */
-    compatible: boolean;
-    conflicts: CompatibilityConflict[];
+/** Map a tuple of {@link FunctionArg} specs to the tuple of JS values `call` receives. */
+type CallArgs<A extends readonly FunctionArg[]> = {
+    [K in keyof A]: JsValue<A[K]["type"]>;
+};
+/**
+ * A declarative function definition.
+ *
+ * `A` and `R` are inferred from the literal `args`/`returns` (via
+ * `defineFunction`'s `const` type parameter), so `call`'s parameters and
+ * return are typed from the declaration with no annotations: an
+ * `{ type: "number" }` argument arrives as a `number`, and a `returns:
+ * "string"` demands a `string` back.
+ */
+interface FunctionSpec<A extends readonly FunctionArg[] = readonly FunctionArg[], R extends FunctionValueType = FunctionValueType> {
+    /**
+     * The call name, a single identifier (`/^[a-z_][a-z0-9_]*$/i`). Registered
+     * as a lexer keyword, so it is matched case-insensitively and cannot collide
+     * with a built-in keyword (that collision throws at registration time).
+     */
+    name: string;
+    /** The parameters, in order. A fixed-length list: variadic and optional args are out of scope (see {@link defineFunction}). */
+    args: A;
+    /** The value type the function returns. */
+    returns: R;
+    /** The implementation, receiving plain JS values and returning one. Must be synchronous (see {@link defineFunction}). */
+    call: (...args: CallArgs<A>) => JsValue<R>;
 }
 /**
- * Statically check `candidate` against every package in `existing` for
- * overlapping/conflicting declarations, across every collision-capable
- * field `IEnginePackage` has. Pure and side-effect-free, does not touch
- * any shared registry, does not require a live `ExpressionEngine`.
+ * Error codes the declarative function API raises. Kept as a co-located const
+ * (the convention `errors/ErrorCode.ts` documents for a domain's own codes) so
+ * the strings have one source of truth.
+ */
+declare const DefineFunctionErrorCodes: {
+    /** The spec's `name` is not a single identifier. Thrown by `defineFunction`, before any engine sees it. */
+    readonly DEFINE_FUNCTION_INVALID_NAME: "DEFINE_FUNCTION_INVALID_NAME";
+    /** The spec is otherwise malformed (bad `args`, unsupported type, missing `call`). Thrown by `defineFunction`. */
+    readonly DEFINE_FUNCTION_INVALID_SPEC: "DEFINE_FUNCTION_INVALID_SPEC";
+    /** The call site passed the wrong number of arguments. Raised at evaluation time. */
+    readonly DEFINE_FUNCTION_ARITY_MISMATCH: "DEFINE_FUNCTION_ARITY_MISMATCH";
+    /** An argument was the wrong value type. Raised at evaluation time. */
+    readonly DEFINE_FUNCTION_ARGUMENT_TYPE: "DEFINE_FUNCTION_ARGUMENT_TYPE";
+    /** The `call` implementation returned a value that did not match `returns`. Raised at evaluation time, an authoring bug rather than a user one. */
+    readonly DEFINE_FUNCTION_RETURN_TYPE: "DEFINE_FUNCTION_RETURN_TYPE";
+};
+/**
+ * Turn a declarative {@link FunctionSpec} into a ready-to-register
+ * {@link IEnginePackage}.
+ *
+ * This is the higher-level API from issue #102. It derives, from the
+ * declaration alone, everything the low-level contract asks an author to write
+ * by hand: a plugin function index ({@link allocatePluginFunctionIndex}), a
+ * lexer keyword so the name tokenises, a call-syntax parselet emitting
+ * `CALL_PLUGIN`, and a handler that checks arity and argument types (yielding
+ * the engine's own structured errors) before invoking `call` and wrapping its
+ * result. Anything needing custom parsing keeps writing a raw parselet exactly
+ * as before, this sits on top of that contract and does not change it.
  *
  * @example
  * ```ts
- * const report = checkPackageCompatibility(myNewPackage, BUILTIN_PACKAGES);
- * if (!report.compatible) {
- *   for (const c of report.conflicts) console.error(c.detail);
- * }
+ * const engine = new ExpressionEngine("en", false, undefined, undefined, [
+ *   ...BUILTIN_PACKAGES,
+ *   defineFunction({
+ *     name: "vat",
+ *     args: [{ name: "amount", type: "number" }],
+ *     returns: "number",
+ *     call: (amount) => amount * 1.2,
+ *   }),
+ * ]);
+ * engine.evaluateExpression("vat(100)"); // 120
  * ```
+ *
+ * The returned package is self-contained and composes with any others through
+ * the engine's `packages` array; register several functions by passing several
+ * packages. Its name is `solve-fn-<name>`.
+ *
+ * Scope: arguments are a fixed-length list of `number`/`string`/`boolean`, and
+ * `call` is synchronous. Variadic and optional arguments, other value types
+ * (units, percentages, dates, matrices), and async work are deliberately out
+ * of scope, a function needing any of those keeps using the low-level
+ * contract, whose parselets and async resolvers are unchanged.
+ *
+ * @throws {EngineError} (category CONFIG) if the spec is malformed, at the
+ * point `defineFunction` is called, before the package reaches an engine.
  */
-declare function checkPackageCompatibility(candidate: IEnginePackage, existing: IEnginePackage[]): CompatibilityReport;
+declare function defineFunction<const A extends readonly FunctionArg[], R extends FunctionValueType>(spec: FunctionSpec<A, R>): IEnginePackage;
 
 /**
  * Engine-version package compatibility gating, the "reject a package built
@@ -149,4 +185,4 @@ declare function checkEngineVersionCompatibility(pkg: IEnginePackage, engineVers
  */
 declare function assertEngineVersionCompatible(pkg: IEnginePackage, engineVersion?: string): void;
 
-export { type CompatibilityConflict, type CompatibilityConflictKind, type CompatibilityReport, type CompatibilitySeverity, type EngineVersionCheckResult, IEnginePackage, assertEngineVersionCompatible, checkEngineVersionCompatibility, checkPackageCompatibility };
+export { DefineFunctionErrorCodes, type EngineVersionCheckResult, type FunctionArg, type FunctionSpec, type FunctionValueType, IEnginePackage, assertEngineVersionCompatible, checkEngineVersionCompatibility, defineFunction };