@layerzerolabs/base-definitions 0.0.44 → 0.0.46

package/.turbo/turbo-build.log

@@ -14,41 +14,41 @@
 CJS dist/index.cjs                1.12 KB
 CJS dist/lzyringe.cjs             302.00 B
 CJS dist/registrarBuilder.cjs     320.00 B
-CJS dist/utils.cjs                341.00 B
 CJS dist/JKTGUQY4.cjs             1.70 KB
-CJS dist/OLE2MTBK.cjs             4.11 KB
-CJS dist/BJOVDE43.cjs             812.00 B
+CJS dist/utils.cjs                341.00 B
+CJS dist/EVDGRGJ5.cjs             4.11 KB
+CJS dist/ZSYU3OBT.cjs             812.00 B
 CJS dist/YJF4D23A.cjs             245.00 B
-CJS dist/GD77KZDY.cjs             1.28 KB
+CJS dist/U3E5EB56.cjs             1.28 KB
 CJS dist/definitions.cjs.map      76.00 B
 CJS dist/index.cjs.map            70.00 B
+CJS dist/lzyringe.cjs.map         73.00 B
+CJS dist/JKTGUQY4.cjs.map         3.78 KB
 CJS dist/registrarBuilder.cjs.map 81.00 B
 CJS dist/utils.cjs.map            70.00 B
-CJS dist/BJOVDE43.cjs.map         1.83 KB
-CJS dist/JKTGUQY4.cjs.map         3.78 KB
+CJS dist/EVDGRGJ5.cjs.map         11.41 KB
+CJS dist/ZSYU3OBT.cjs.map         1.83 KB
 CJS dist/YJF4D23A.cjs.map         73.00 B
-CJS dist/OLE2MTBK.cjs.map         11.41 KB
-CJS dist/GD77KZDY.cjs.map         12.18 KB
-CJS dist/lzyringe.cjs.map         73.00 B
-CJS ⚡️ Build success in 218ms
+CJS dist/U3E5EB56.cjs.map         12.97 KB
+CJS ⚡️ Build success in 151ms
+ESM dist/lzyringe.js             146.00 B
 ESM dist/definitions.js          193.00 B
 ESM dist/index.js                338.00 B
-ESM dist/lzyringe.js             146.00 B
 ESM dist/JJBD65HU.js             1.65 KB
 ESM dist/registrarBuilder.js     163.00 B
-ESM dist/RGGHMCTO.js             4.01 KB
 ESM dist/utils.js                173.00 B
-ESM dist/P5NNX2LK.js             733.00 B
+ESM dist/6D5TVHOU.js             4.01 KB
 ESM dist/VUOMXK5T.js             222.00 B
-ESM dist/3GFGHSFN.js             1.12 KB
-ESM dist/index.js.map            69.00 B
+ESM dist/JV365MVS.js             1.12 KB
+ESM dist/G24SMCHK.js             733.00 B
 ESM dist/definitions.js.map      75.00 B
 ESM dist/lzyringe.js.map         72.00 B
+ESM dist/index.js.map            69.00 B
 ESM dist/registrarBuilder.js.map 80.00 B
 ESM dist/JJBD65HU.js.map         3.78 KB
 ESM dist/utils.js.map            69.00 B
-ESM dist/P5NNX2LK.js.map         1.82 KB
-ESM dist/RGGHMCTO.js.map         11.39 KB
+ESM dist/6D5TVHOU.js.map         11.40 KB
 ESM dist/VUOMXK5T.js.map         72.00 B
-ESM dist/3GFGHSFN.js.map         12.16 KB
-ESM ⚡️ Build success in 219ms
+ESM dist/JV365MVS.js.map         12.95 KB
+ESM dist/G24SMCHK.js.map         1.82 KB
+ESM ⚡️ Build success in 152ms

package/.turbo/turbo-test.log

@@ -5,10 +5,10 @@
 
  RUN  v3.2.3 /home/runner/work/monorepo-internal/monorepo-internal/packages/framework/definitions/base-definitions
 
- ✓ test/registrarBuilder.test.ts (4 tests) 8ms
+ ✓ test/registrarBuilder.test.ts (4 tests) 6ms
 
  Test Files  1 passed (1)
       Tests  4 passed (4)
-   Start at  16:11:14
-   Duration  726ms (transform 141ms, setup 0ms, collect 103ms, tests 8ms, environment 0ms, prepare 232ms)
+   Start at  22:54:05
+   Duration  317ms (transform 65ms, setup 0ms, collect 64ms, tests 6ms, environment 0ms, prepare 84ms)
 

package/dist/{RGGHMCTO.js → 6D5TVHOU.js}

@@ -130,5 +130,5 @@ var RegistrarBuilder = class {
 };
 
 export { RegistrarBuilder };
-//# sourceMappingURL=RGGHMCTO.js.map
-//# sourceMappingURL=RGGHMCTO.js.map
+//# sourceMappingURL=6D5TVHOU.js.map
+//# sourceMappingURL=6D5TVHOU.js.map

package/dist/{RGGHMCTO.js.map → 6D5TVHOU.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/registrarBuilder.ts"],"names":["RegistrarBuilder","defaultHandler","node","Error","JSON","stringify","classHandlers","classAliases","addClassHandler","nodeClass","identifier","fn","find","fromNodeClass","i","handler","prototype","isPrototypeOf","splice","push","addClassAlias","getToNode","alias","addDefault","build","mergedNodePrehandler","toNode","mergedNodeHandler","ancestry","key","value","traverseDependencies","dfs"],"mappings":"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","file":"RGGHMCTO.js","sourcesContent":["import type { DependencyNode } from '@layerzerolabs/dependency-graph';\nimport type { Registrar } from '@layerzerolabs/dfs';\nexport type { Registrar };\nimport { dfs } from '@layerzerolabs/dfs';\n\ntype NodeClass = new (...args: any[]) => DependencyNode;\ntype AbstractNodeClass = abstract new (...args: any[]) => DependencyNode;\n\n/**\n * <!-- anchor:RegistrarBuilder -->\n * A builder class for a {@link Registrar}.\n * Builds a registrar that switches on node class--i.e., enables defining\n * specific registration behaviour for specific node classes.\n * Intelligently handles inheritance, always using the most specific\n * handler defined for any given class.\n * The registrar built shall return an object that maps from a handler ID,\n * to a map from node name to the return of each handler,\n * e.g., { objectNodes: { myObjectNode: 'my handler return' }}.\n * This can be used to extract a specific resolved value after resolving the tree,\n * given that the handlers return the resolved nodes.\n */\nexport class RegistrarBuilder<_ReturnTypes> {\n    protected defaultHandler: (node: DependencyNode, ancestry: DependencyNode[]) => Promise<any>;\n    constructor() {\n        this.defaultHandler = async (node: DependencyNode) => {\n            throw new Error(\n                `This registrar does not provide a handler for the dependency type used by ${JSON.stringify(node)}`,\n            );\n        };\n    }\n\n    protected classHandlers: {\n        nodeClass: AbstractNodeClass;\n        identifier: string;\n        fn: (node: DependencyNode, ancestry: DependencyNode[]) => Promise<any>;\n    }[] = [];\n\n    protected classAliases: {\n        fromNodeClass: AbstractNodeClass;\n        getToNode: (from: DependencyNode) => DependencyNode;\n    }[] = [];\n\n    /**\n     * Add a function fn to be called on all nodes of class\n     * @param nodeClass\n     * @param identifier\n     * @param fn\n     */\n    public addClassHandler<\n        Identifier extends string,\n        _NodeClass extends NodeClass,\n        Function extends (node: InstanceType<_NodeClass>, ancestry: DependencyNode[]) => any,\n    >(nodeClass: _NodeClass, identifier: Identifier, fn: Function) {\n        if (this.classAliases.find(({ fromNodeClass }) => fromNodeClass === nodeClass)) {\n            throw new Error(\n                `Cannot define a handler for a class that is aliased to something else. This would be pointless`,\n            );\n        }\n\n        let i = 0;\n        for (const handler of this.classHandlers) {\n            //check if we are overriding an existing handler\n            if (handler.nodeClass === nodeClass) {\n                this.classHandlers[i] = {\n                    nodeClass,\n                    identifier,\n                    fn: fn as unknown as (node: DependencyNode) => Promise<any>,\n                };\n\n                return this as RegistrarBuilder<\n                    _ReturnTypes & {\n                        [K in Identifier]: { [nodeName: string]: Awaited<ReturnType<Function>> };\n                    }\n                >;\n            }\n            //check if the new handler has an ordering requirement against an existing handler\n            //(we always want to use more specific handlers if they exist)\n            // eslint-disable-next-line no-prototype-builtins\n            if (handler.nodeClass.prototype.isPrototypeOf(nodeClass.prototype)) {\n                this.classHandlers.splice(i, 0, {\n                    nodeClass,\n                    identifier,\n                    fn: fn as unknown as (node: DependencyNode) => Promise<any>,\n                });\n\n                return this as RegistrarBuilder<\n                    _ReturnTypes & {\n                        [K in Identifier]: { [nodeName: string]: Awaited<ReturnType<Function>> };\n                    }\n                >;\n            }\n            i++;\n        }\n\n        this.classHandlers.push({\n            nodeClass,\n            identifier,\n            fn: fn as unknown as (node: DependencyNode) => Promise<any>,\n        });\n\n        return this as RegistrarBuilder<\n            _ReturnTypes & {\n                [K in Identifier]: { [nodeName: string]: Awaited<ReturnType<Function>> };\n            }\n        >;\n    }\n\n    /**\n     * Alias some class *from*, such that any node of that class in the tree will be\n     * treated as though it were some other node *to*. The *to* node is given as a\n     * function returning a class instance, so that its dependencies, name, etc can be fixed.\n     * The registrar will ignore the dependencies of the original node, and follow the alias's\n     * dependencies instead.\n     *\n     * Additionally, this method does not affect the typing of the registrar. The output type\n     * of the build() method will not reflect the alias.\n     *\n     * @param fromNodeClass alias instances of this class\n     * @param getToNode method that returns the *to* part of the alias\n     */\n    public addClassAlias<FromNodeClass extends AbstractNodeClass>(\n        fromNodeClass: FromNodeClass,\n        getToNode: (fromNodeInstance: InstanceType<FromNodeClass>) => DependencyNode,\n    ) {\n        if (this.classHandlers.find(({ nodeClass }) => nodeClass === fromNodeClass)) {\n            throw new Error(`Cannot define an alias for a class that already has a handler`);\n        }\n\n        let i = 0;\n        for (const alias of this.classAliases) {\n            //check if we are overriding an existing alias\n            if (alias.fromNodeClass === fromNodeClass) {\n                this.classAliases[i] = {\n                    fromNodeClass,\n                    getToNode: getToNode as unknown as (from: DependencyNode) => DependencyNode,\n                };\n\n                return this;\n            }\n            //check if the new alias has an ordering requirement against an existing alias\n            //(we always want to use more specific handlers if they exist)\n            // eslint-disable-next-line no-prototype-builtins\n            if (alias.fromNodeClass.prototype.isPrototypeOf(fromNodeClass.prototype)) {\n                this.classAliases.splice(i, 0, {\n                    fromNodeClass,\n                    getToNode: getToNode as unknown as (from: DependencyNode) => DependencyNode,\n                });\n\n                return this;\n            }\n            i++;\n        }\n\n        this.classAliases.push({\n            fromNodeClass,\n            getToNode: getToNode as unknown as (from: DependencyNode) => DependencyNode,\n        });\n\n        return this;\n    }\n\n    /**\n     * Add a default function fn to be used on nodes whose types do not have handlers.\n     * If this is not set, the default behaviour will be to throw\n     * @param fn\n     */\n    public addDefault(fn: (node: DependencyNode, ancestry: DependencyNode[]) => any) {\n        this.defaultHandler = fn;\n        return this;\n    }\n\n    public build(): Registrar<_ReturnTypes> {\n        const mergedNodePrehandler = (node: DependencyNode) => {\n            for (const { fromNodeClass, getToNode: toNode } of this.classAliases) {\n                if (node instanceof fromNodeClass) {\n                    return toNode(node);\n                }\n            }\n            return node;\n        };\n\n        const mergedNodeHandler = async (node: DependencyNode, ancestry: DependencyNode[]) => {\n            for (const { nodeClass, identifier, fn } of this.classHandlers) {\n                if (node instanceof nodeClass) {\n                    return {\n                        key: identifier,\n                        value: await fn(node, ancestry),\n                    };\n                }\n            }\n\n            return {\n                key: 'default',\n                value: await this.defaultHandler(node, ancestry),\n            };\n        };\n        return {\n            traverseDependencies: async (node: DependencyNode) =>\n                await dfs<_ReturnTypes>(node, mergedNodeHandler, mergedNodePrehandler)(),\n        };\n    }\n}\n"]}
+{"version":3,"sources":["../src/registrarBuilder.ts"],"names":["RegistrarBuilder","defaultHandler","node","Error","JSON","stringify","classHandlers","classAliases","addClassHandler","nodeClass","identifier","fn","find","fromNodeClass","i","handler","prototype","isPrototypeOf","splice","push","addClassAlias","getToNode","alias","addDefault","build","mergedNodePrehandler","toNode","mergedNodeHandler","ancestry","key","value","traverseDependencies","dfs"],"mappings":"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","file":"6D5TVHOU.js","sourcesContent":["import type { DependencyNode } from '@layerzerolabs/dependency-graph';\nimport type { Registrar } from '@layerzerolabs/dfs';\nimport { dfs } from '@layerzerolabs/dfs';\nexport type { Registrar };\n\ntype NodeClass = new (...args: any[]) => DependencyNode;\ntype AbstractNodeClass = abstract new (...args: any[]) => DependencyNode;\n\n/**\n * <!-- anchor:RegistrarBuilder -->\n * A builder class for a {@link Registrar}.\n * Builds a registrar that switches on node class--i.e., enables defining\n * specific registration behaviour for specific node classes.\n * Intelligently handles inheritance, always using the most specific\n * handler defined for any given class.\n * The registrar built shall return an object that maps from a handler ID,\n * to a map from node name to the return of each handler,\n * e.g., { objectNodes: { myObjectNode: 'my handler return' }}.\n * This can be used to extract a specific resolved value after resolving the tree,\n * given that the handlers return the resolved nodes.\n */\nexport class RegistrarBuilder<_ReturnTypes> {\n    protected defaultHandler: (node: DependencyNode, ancestry: DependencyNode[]) => Promise<any>;\n    constructor() {\n        this.defaultHandler = async (node: DependencyNode) => {\n            throw new Error(\n                `This registrar does not provide a handler for the dependency type used by ${JSON.stringify(node)}`,\n            );\n        };\n    }\n\n    protected classHandlers: {\n        nodeClass: AbstractNodeClass;\n        identifier: string;\n        fn: (node: DependencyNode, ancestry: DependencyNode[]) => Promise<any>;\n    }[] = [];\n\n    protected classAliases: {\n        fromNodeClass: AbstractNodeClass;\n        getToNode: (from: DependencyNode) => DependencyNode;\n    }[] = [];\n\n    /**\n     * Add a function fn to be called on all nodes of class\n     * @param nodeClass\n     * @param identifier\n     * @param fn\n     */\n    public addClassHandler<\n        Identifier extends string,\n        _NodeClass extends NodeClass,\n        Function extends (node: InstanceType<_NodeClass>, ancestry: DependencyNode[]) => any,\n    >(nodeClass: _NodeClass, identifier: Identifier, fn: Function) {\n        if (this.classAliases.find(({ fromNodeClass }) => fromNodeClass === nodeClass)) {\n            throw new Error(\n                `Cannot define a handler for a class that is aliased to something else. This would be pointless`,\n            );\n        }\n\n        let i = 0;\n        for (const handler of this.classHandlers) {\n            //check if we are overriding an existing handler\n            if (handler.nodeClass === nodeClass) {\n                this.classHandlers[i] = {\n                    nodeClass,\n                    identifier,\n                    fn: fn as unknown as (node: DependencyNode) => Promise<any>,\n                };\n\n                return this as RegistrarBuilder<\n                    _ReturnTypes & {\n                        [_K in Identifier]: { [nodeName: string]: Awaited<ReturnType<Function>> };\n                    }\n                >;\n            }\n            //check if the new handler has an ordering requirement against an existing handler\n            //(we always want to use more specific handlers if they exist)\n            // eslint-disable-next-line no-prototype-builtins\n            if (handler.nodeClass.prototype.isPrototypeOf(nodeClass.prototype)) {\n                this.classHandlers.splice(i, 0, {\n                    nodeClass,\n                    identifier,\n                    fn: fn as unknown as (node: DependencyNode) => Promise<any>,\n                });\n\n                return this as RegistrarBuilder<\n                    _ReturnTypes & {\n                        [_K in Identifier]: { [nodeName: string]: Awaited<ReturnType<Function>> };\n                    }\n                >;\n            }\n            i++;\n        }\n\n        this.classHandlers.push({\n            nodeClass,\n            identifier,\n            fn: fn as unknown as (node: DependencyNode) => Promise<any>,\n        });\n\n        return this as RegistrarBuilder<\n            _ReturnTypes & {\n                [_K in Identifier]: { [nodeName: string]: Awaited<ReturnType<Function>> };\n            }\n        >;\n    }\n\n    /**\n     * Alias some class *from*, such that any node of that class in the tree will be\n     * treated as though it were some other node *to*. The *to* node is given as a\n     * function returning a class instance, so that its dependencies, name, etc can be fixed.\n     * The registrar will ignore the dependencies of the original node, and follow the alias's\n     * dependencies instead.\n     *\n     * Additionally, this method does not affect the typing of the registrar. The output type\n     * of the build() method will not reflect the alias.\n     *\n     * @param fromNodeClass alias instances of this class\n     * @param getToNode method that returns the *to* part of the alias\n     */\n    public addClassAlias<FromNodeClass extends AbstractNodeClass>(\n        fromNodeClass: FromNodeClass,\n        getToNode: (fromNodeInstance: InstanceType<FromNodeClass>) => DependencyNode,\n    ) {\n        if (this.classHandlers.find(({ nodeClass }) => nodeClass === fromNodeClass)) {\n            throw new Error(`Cannot define an alias for a class that already has a handler`);\n        }\n\n        let i = 0;\n        for (const alias of this.classAliases) {\n            //check if we are overriding an existing alias\n            if (alias.fromNodeClass === fromNodeClass) {\n                this.classAliases[i] = {\n                    fromNodeClass,\n                    getToNode: getToNode as unknown as (from: DependencyNode) => DependencyNode,\n                };\n\n                return this;\n            }\n            //check if the new alias has an ordering requirement against an existing alias\n            //(we always want to use more specific handlers if they exist)\n            // eslint-disable-next-line no-prototype-builtins\n            if (alias.fromNodeClass.prototype.isPrototypeOf(fromNodeClass.prototype)) {\n                this.classAliases.splice(i, 0, {\n                    fromNodeClass,\n                    getToNode: getToNode as unknown as (from: DependencyNode) => DependencyNode,\n                });\n\n                return this;\n            }\n            i++;\n        }\n\n        this.classAliases.push({\n            fromNodeClass,\n            getToNode: getToNode as unknown as (from: DependencyNode) => DependencyNode,\n        });\n\n        return this;\n    }\n\n    /**\n     * Add a default function fn to be used on nodes whose types do not have handlers.\n     * If this is not set, the default behaviour will be to throw\n     * @param fn\n     */\n    public addDefault(fn: (node: DependencyNode, ancestry: DependencyNode[]) => any) {\n        this.defaultHandler = fn;\n        return this;\n    }\n\n    public build(): Registrar<_ReturnTypes> {\n        const mergedNodePrehandler = (node: DependencyNode) => {\n            for (const { fromNodeClass, getToNode: toNode } of this.classAliases) {\n                if (node instanceof fromNodeClass) {\n                    return toNode(node);\n                }\n            }\n            return node;\n        };\n\n        const mergedNodeHandler = async (node: DependencyNode, ancestry: DependencyNode[]) => {\n            for (const { nodeClass, identifier, fn } of this.classHandlers) {\n                if (node instanceof nodeClass) {\n                    return {\n                        key: identifier,\n                        value: await fn(node, ancestry),\n                    };\n                }\n            }\n\n            return {\n                key: 'default',\n                value: await this.defaultHandler(node, ancestry),\n            };\n        };\n        return {\n            traverseDependencies: async (node: DependencyNode) =>\n                await dfs<_ReturnTypes>(node, mergedNodeHandler, mergedNodePrehandler)(),\n        };\n    }\n}\n"]}

package/dist/{OLE2MTBK.cjs → EVDGRGJ5.cjs}

@@ -132,5 +132,5 @@ var RegistrarBuilder = class {
 };
 
 exports.RegistrarBuilder = RegistrarBuilder;
-//# sourceMappingURL=OLE2MTBK.cjs.map
-//# sourceMappingURL=OLE2MTBK.cjs.map
+//# sourceMappingURL=EVDGRGJ5.cjs.map
+//# sourceMappingURL=EVDGRGJ5.cjs.map

package/dist/{OLE2MTBK.cjs.map → EVDGRGJ5.cjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/registrarBuilder.ts"],"names":["RegistrarBuilder","defaultHandler","node","Error","JSON","stringify","classHandlers","classAliases","addClassHandler","nodeClass","identifier","fn","find","fromNodeClass","i","handler","prototype","isPrototypeOf","splice","push","addClassAlias","getToNode","alias","addDefault","build","mergedNodePrehandler","toNode","mergedNodeHandler","__name","ancestry","key","value","traverseDependencies","dfs"],"mappings":"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","file":"OLE2MTBK.cjs","sourcesContent":["import type { DependencyNode } from '@layerzerolabs/dependency-graph';\nimport type { Registrar } from '@layerzerolabs/dfs';\nexport type { Registrar };\nimport { dfs } from '@layerzerolabs/dfs';\n\ntype NodeClass = new (...args: any[]) => DependencyNode;\ntype AbstractNodeClass = abstract new (...args: any[]) => DependencyNode;\n\n/**\n * <!-- anchor:RegistrarBuilder -->\n * A builder class for a {@link Registrar}.\n * Builds a registrar that switches on node class--i.e., enables defining\n * specific registration behaviour for specific node classes.\n * Intelligently handles inheritance, always using the most specific\n * handler defined for any given class.\n * The registrar built shall return an object that maps from a handler ID,\n * to a map from node name to the return of each handler,\n * e.g., { objectNodes: { myObjectNode: 'my handler return' }}.\n * This can be used to extract a specific resolved value after resolving the tree,\n * given that the handlers return the resolved nodes.\n */\nexport class RegistrarBuilder<_ReturnTypes> {\n    protected defaultHandler: (node: DependencyNode, ancestry: DependencyNode[]) => Promise<any>;\n    constructor() {\n        this.defaultHandler = async (node: DependencyNode) => {\n            throw new Error(\n                `This registrar does not provide a handler for the dependency type used by ${JSON.stringify(node)}`,\n            );\n        };\n    }\n\n    protected classHandlers: {\n        nodeClass: AbstractNodeClass;\n        identifier: string;\n        fn: (node: DependencyNode, ancestry: DependencyNode[]) => Promise<any>;\n    }[] = [];\n\n    protected classAliases: {\n        fromNodeClass: AbstractNodeClass;\n        getToNode: (from: DependencyNode) => DependencyNode;\n    }[] = [];\n\n    /**\n     * Add a function fn to be called on all nodes of class\n     * @param nodeClass\n     * @param identifier\n     * @param fn\n     */\n    public addClassHandler<\n        Identifier extends string,\n        _NodeClass extends NodeClass,\n        Function extends (node: InstanceType<_NodeClass>, ancestry: DependencyNode[]) => any,\n    >(nodeClass: _NodeClass, identifier: Identifier, fn: Function) {\n        if (this.classAliases.find(({ fromNodeClass }) => fromNodeClass === nodeClass)) {\n            throw new Error(\n                `Cannot define a handler for a class that is aliased to something else. This would be pointless`,\n            );\n        }\n\n        let i = 0;\n        for (const handler of this.classHandlers) {\n            //check if we are overriding an existing handler\n            if (handler.nodeClass === nodeClass) {\n                this.classHandlers[i] = {\n                    nodeClass,\n                    identifier,\n                    fn: fn as unknown as (node: DependencyNode) => Promise<any>,\n                };\n\n                return this as RegistrarBuilder<\n                    _ReturnTypes & {\n                        [K in Identifier]: { [nodeName: string]: Awaited<ReturnType<Function>> };\n                    }\n                >;\n            }\n            //check if the new handler has an ordering requirement against an existing handler\n            //(we always want to use more specific handlers if they exist)\n            // eslint-disable-next-line no-prototype-builtins\n            if (handler.nodeClass.prototype.isPrototypeOf(nodeClass.prototype)) {\n                this.classHandlers.splice(i, 0, {\n                    nodeClass,\n                    identifier,\n                    fn: fn as unknown as (node: DependencyNode) => Promise<any>,\n                });\n\n                return this as RegistrarBuilder<\n                    _ReturnTypes & {\n                        [K in Identifier]: { [nodeName: string]: Awaited<ReturnType<Function>> };\n                    }\n                >;\n            }\n            i++;\n        }\n\n        this.classHandlers.push({\n            nodeClass,\n            identifier,\n            fn: fn as unknown as (node: DependencyNode) => Promise<any>,\n        });\n\n        return this as RegistrarBuilder<\n            _ReturnTypes & {\n                [K in Identifier]: { [nodeName: string]: Awaited<ReturnType<Function>> };\n            }\n        >;\n    }\n\n    /**\n     * Alias some class *from*, such that any node of that class in the tree will be\n     * treated as though it were some other node *to*. The *to* node is given as a\n     * function returning a class instance, so that its dependencies, name, etc can be fixed.\n     * The registrar will ignore the dependencies of the original node, and follow the alias's\n     * dependencies instead.\n     *\n     * Additionally, this method does not affect the typing of the registrar. The output type\n     * of the build() method will not reflect the alias.\n     *\n     * @param fromNodeClass alias instances of this class\n     * @param getToNode method that returns the *to* part of the alias\n     */\n    public addClassAlias<FromNodeClass extends AbstractNodeClass>(\n        fromNodeClass: FromNodeClass,\n        getToNode: (fromNodeInstance: InstanceType<FromNodeClass>) => DependencyNode,\n    ) {\n        if (this.classHandlers.find(({ nodeClass }) => nodeClass === fromNodeClass)) {\n            throw new Error(`Cannot define an alias for a class that already has a handler`);\n        }\n\n        let i = 0;\n        for (const alias of this.classAliases) {\n            //check if we are overriding an existing alias\n            if (alias.fromNodeClass === fromNodeClass) {\n                this.classAliases[i] = {\n                    fromNodeClass,\n                    getToNode: getToNode as unknown as (from: DependencyNode) => DependencyNode,\n                };\n\n                return this;\n            }\n            //check if the new alias has an ordering requirement against an existing alias\n            //(we always want to use more specific handlers if they exist)\n            // eslint-disable-next-line no-prototype-builtins\n            if (alias.fromNodeClass.prototype.isPrototypeOf(fromNodeClass.prototype)) {\n                this.classAliases.splice(i, 0, {\n                    fromNodeClass,\n                    getToNode: getToNode as unknown as (from: DependencyNode) => DependencyNode,\n                });\n\n                return this;\n            }\n            i++;\n        }\n\n        this.classAliases.push({\n            fromNodeClass,\n            getToNode: getToNode as unknown as (from: DependencyNode) => DependencyNode,\n        });\n\n        return this;\n    }\n\n    /**\n     * Add a default function fn to be used on nodes whose types do not have handlers.\n     * If this is not set, the default behaviour will be to throw\n     * @param fn\n     */\n    public addDefault(fn: (node: DependencyNode, ancestry: DependencyNode[]) => any) {\n        this.defaultHandler = fn;\n        return this;\n    }\n\n    public build(): Registrar<_ReturnTypes> {\n        const mergedNodePrehandler = (node: DependencyNode) => {\n            for (const { fromNodeClass, getToNode: toNode } of this.classAliases) {\n                if (node instanceof fromNodeClass) {\n                    return toNode(node);\n                }\n            }\n            return node;\n        };\n\n        const mergedNodeHandler = async (node: DependencyNode, ancestry: DependencyNode[]) => {\n            for (const { nodeClass, identifier, fn } of this.classHandlers) {\n                if (node instanceof nodeClass) {\n                    return {\n                        key: identifier,\n                        value: await fn(node, ancestry),\n                    };\n                }\n            }\n\n            return {\n                key: 'default',\n                value: await this.defaultHandler(node, ancestry),\n            };\n        };\n        return {\n            traverseDependencies: async (node: DependencyNode) =>\n                await dfs<_ReturnTypes>(node, mergedNodeHandler, mergedNodePrehandler)(),\n        };\n    }\n}\n"]}
+{"version":3,"sources":["../src/registrarBuilder.ts"],"names":["RegistrarBuilder","defaultHandler","node","Error","JSON","stringify","classHandlers","classAliases","addClassHandler","nodeClass","identifier","fn","find","fromNodeClass","i","handler","prototype","isPrototypeOf","splice","push","addClassAlias","getToNode","alias","addDefault","build","mergedNodePrehandler","toNode","mergedNodeHandler","__name","ancestry","key","value","traverseDependencies","dfs"],"mappings":"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","file":"EVDGRGJ5.cjs","sourcesContent":["import type { DependencyNode } from '@layerzerolabs/dependency-graph';\nimport type { Registrar } from '@layerzerolabs/dfs';\nimport { dfs } from '@layerzerolabs/dfs';\nexport type { Registrar };\n\ntype NodeClass = new (...args: any[]) => DependencyNode;\ntype AbstractNodeClass = abstract new (...args: any[]) => DependencyNode;\n\n/**\n * <!-- anchor:RegistrarBuilder -->\n * A builder class for a {@link Registrar}.\n * Builds a registrar that switches on node class--i.e., enables defining\n * specific registration behaviour for specific node classes.\n * Intelligently handles inheritance, always using the most specific\n * handler defined for any given class.\n * The registrar built shall return an object that maps from a handler ID,\n * to a map from node name to the return of each handler,\n * e.g., { objectNodes: { myObjectNode: 'my handler return' }}.\n * This can be used to extract a specific resolved value after resolving the tree,\n * given that the handlers return the resolved nodes.\n */\nexport class RegistrarBuilder<_ReturnTypes> {\n    protected defaultHandler: (node: DependencyNode, ancestry: DependencyNode[]) => Promise<any>;\n    constructor() {\n        this.defaultHandler = async (node: DependencyNode) => {\n            throw new Error(\n                `This registrar does not provide a handler for the dependency type used by ${JSON.stringify(node)}`,\n            );\n        };\n    }\n\n    protected classHandlers: {\n        nodeClass: AbstractNodeClass;\n        identifier: string;\n        fn: (node: DependencyNode, ancestry: DependencyNode[]) => Promise<any>;\n    }[] = [];\n\n    protected classAliases: {\n        fromNodeClass: AbstractNodeClass;\n        getToNode: (from: DependencyNode) => DependencyNode;\n    }[] = [];\n\n    /**\n     * Add a function fn to be called on all nodes of class\n     * @param nodeClass\n     * @param identifier\n     * @param fn\n     */\n    public addClassHandler<\n        Identifier extends string,\n        _NodeClass extends NodeClass,\n        Function extends (node: InstanceType<_NodeClass>, ancestry: DependencyNode[]) => any,\n    >(nodeClass: _NodeClass, identifier: Identifier, fn: Function) {\n        if (this.classAliases.find(({ fromNodeClass }) => fromNodeClass === nodeClass)) {\n            throw new Error(\n                `Cannot define a handler for a class that is aliased to something else. This would be pointless`,\n            );\n        }\n\n        let i = 0;\n        for (const handler of this.classHandlers) {\n            //check if we are overriding an existing handler\n            if (handler.nodeClass === nodeClass) {\n                this.classHandlers[i] = {\n                    nodeClass,\n                    identifier,\n                    fn: fn as unknown as (node: DependencyNode) => Promise<any>,\n                };\n\n                return this as RegistrarBuilder<\n                    _ReturnTypes & {\n                        [_K in Identifier]: { [nodeName: string]: Awaited<ReturnType<Function>> };\n                    }\n                >;\n            }\n            //check if the new handler has an ordering requirement against an existing handler\n            //(we always want to use more specific handlers if they exist)\n            // eslint-disable-next-line no-prototype-builtins\n            if (handler.nodeClass.prototype.isPrototypeOf(nodeClass.prototype)) {\n                this.classHandlers.splice(i, 0, {\n                    nodeClass,\n                    identifier,\n                    fn: fn as unknown as (node: DependencyNode) => Promise<any>,\n                });\n\n                return this as RegistrarBuilder<\n                    _ReturnTypes & {\n                        [_K in Identifier]: { [nodeName: string]: Awaited<ReturnType<Function>> };\n                    }\n                >;\n            }\n            i++;\n        }\n\n        this.classHandlers.push({\n            nodeClass,\n            identifier,\n            fn: fn as unknown as (node: DependencyNode) => Promise<any>,\n        });\n\n        return this as RegistrarBuilder<\n            _ReturnTypes & {\n                [_K in Identifier]: { [nodeName: string]: Awaited<ReturnType<Function>> };\n            }\n        >;\n    }\n\n    /**\n     * Alias some class *from*, such that any node of that class in the tree will be\n     * treated as though it were some other node *to*. The *to* node is given as a\n     * function returning a class instance, so that its dependencies, name, etc can be fixed.\n     * The registrar will ignore the dependencies of the original node, and follow the alias's\n     * dependencies instead.\n     *\n     * Additionally, this method does not affect the typing of the registrar. The output type\n     * of the build() method will not reflect the alias.\n     *\n     * @param fromNodeClass alias instances of this class\n     * @param getToNode method that returns the *to* part of the alias\n     */\n    public addClassAlias<FromNodeClass extends AbstractNodeClass>(\n        fromNodeClass: FromNodeClass,\n        getToNode: (fromNodeInstance: InstanceType<FromNodeClass>) => DependencyNode,\n    ) {\n        if (this.classHandlers.find(({ nodeClass }) => nodeClass === fromNodeClass)) {\n            throw new Error(`Cannot define an alias for a class that already has a handler`);\n        }\n\n        let i = 0;\n        for (const alias of this.classAliases) {\n            //check if we are overriding an existing alias\n            if (alias.fromNodeClass === fromNodeClass) {\n                this.classAliases[i] = {\n                    fromNodeClass,\n                    getToNode: getToNode as unknown as (from: DependencyNode) => DependencyNode,\n                };\n\n                return this;\n            }\n            //check if the new alias has an ordering requirement against an existing alias\n            //(we always want to use more specific handlers if they exist)\n            // eslint-disable-next-line no-prototype-builtins\n            if (alias.fromNodeClass.prototype.isPrototypeOf(fromNodeClass.prototype)) {\n                this.classAliases.splice(i, 0, {\n                    fromNodeClass,\n                    getToNode: getToNode as unknown as (from: DependencyNode) => DependencyNode,\n                });\n\n                return this;\n            }\n            i++;\n        }\n\n        this.classAliases.push({\n            fromNodeClass,\n            getToNode: getToNode as unknown as (from: DependencyNode) => DependencyNode,\n        });\n\n        return this;\n    }\n\n    /**\n     * Add a default function fn to be used on nodes whose types do not have handlers.\n     * If this is not set, the default behaviour will be to throw\n     * @param fn\n     */\n    public addDefault(fn: (node: DependencyNode, ancestry: DependencyNode[]) => any) {\n        this.defaultHandler = fn;\n        return this;\n    }\n\n    public build(): Registrar<_ReturnTypes> {\n        const mergedNodePrehandler = (node: DependencyNode) => {\n            for (const { fromNodeClass, getToNode: toNode } of this.classAliases) {\n                if (node instanceof fromNodeClass) {\n                    return toNode(node);\n                }\n            }\n            return node;\n        };\n\n        const mergedNodeHandler = async (node: DependencyNode, ancestry: DependencyNode[]) => {\n            for (const { nodeClass, identifier, fn } of this.classHandlers) {\n                if (node instanceof nodeClass) {\n                    return {\n                        key: identifier,\n                        value: await fn(node, ancestry),\n                    };\n                }\n            }\n\n            return {\n                key: 'default',\n                value: await this.defaultHandler(node, ancestry),\n            };\n        };\n        return {\n            traverseDependencies: async (node: DependencyNode) =>\n                await dfs<_ReturnTypes>(node, mergedNodeHandler, mergedNodePrehandler)(),\n        };\n    }\n}\n"]}

package/dist/{P5NNX2LK.js → G24SMCHK.js}

@@ -1,4 +1,4 @@
-import { serializeDimensions } from './3GFGHSFN.js';
+import { serializeDimensions } from './JV365MVS.js';
 import { __name } from './VUOMXK5T.js';
 
 // src/utils.ts
@@ -11,5 +11,5 @@ var extractSchemaFromFactory = /* @__PURE__ */ __name((factory, dimension) => {
 }, "extractSchemaFromFactory");
 
 export { extractSchemaFromFactory };
-//# sourceMappingURL=P5NNX2LK.js.map
-//# sourceMappingURL=P5NNX2LK.js.map
+//# sourceMappingURL=G24SMCHK.js.map
+//# sourceMappingURL=G24SMCHK.js.map

package/dist/{P5NNX2LK.js.map → G24SMCHK.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/utils.ts"],"names":["extractSchemaFromFactory","factory","dimension","schema","dimensionToSchemaMap","byDimension","Object","values","find","dim","serializeDimensions","base","shape","Error","name","JSON","stringify"],"mappings":";;;;AAOO,IAAMA,wBAAAA,mBAA2B,MAAA,CAAA,CACpCC,OAAAA,EACAC,SAAAA,KAAAA;AAEA,EAAA,MAAMC,MAAAA,GAAAA,CACDF,OAAAA,CAAQG,oBAAAA,CAAqBC,WAAAA,IAC1BC,MAAAA,CAAOC,OAAON,OAAAA,CAAQG,oBAAAA,CAAqBC,WAAW,CAAA,CAAoBG,IAAAA,CACtE,CAAC,CAACC,GAAAA,CAAAA,KAASC,mBAAAA,CAAoBD,GAAAA,CAAAA,KAASC,mBAAAA,CAAoBR,SAAAA,CAAAA,CAAAA,GAC5D,CAAA,CAAA,KACRD,OAAAA,CAAQG,oBAAAA,CAAqBO,IAAAA;AACjC,EAAA,IAAI,CAACR,QAAQS,KAAAA,EAAO;AAChB,IAAA,MAAM,IAAIC,KAAAA,CACN,CAAA,uCAAA,EAA0CZ,OAAAA,CAAQa,IAAI,YAAYC,IAAAA,CAAKC,SAAAA,CAAUd,SAAAA,CAAAA,CAAAA,CAAY,CAAA;AAErG,EAAA;AAEA,EAAA,OAAOC,MAAAA;AACX,CAAA,EAjBwC,0BAAA","file":"P5NNX2LK.js","sourcesContent":["import type z from 'zod/v4';\n\nimport type { AdvancedRecord } from '@layerzerolabs/typescript-utils';\n\nimport type { Factory } from './definitions';\nimport { type FactoryDefinition, serializeDimensions } from './definitions';\n\nexport const extractSchemaFromFactory = <Dim extends z.ZodObject>(\n    factory: FactoryDefinition<any, Dim, any, any, any> | Factory<any, any, any, any>,\n    dimension: z.infer<Dim>,\n): z.ZodObject => {\n    const schema =\n        (factory.dimensionToSchemaMap.byDimension &&\n            Object.values(factory.dimensionToSchemaMap.byDimension as AdvancedRecord).find(\n                ([dim]) => serializeDimensions(dim) === serializeDimensions(dimension),\n            )?.[1]) ??\n        factory.dimensionToSchemaMap.base;\n    if (!schema?.shape) {\n        throw new Error(\n            `Couldn't resolve the schema of factory ${factory.name} for dim ${JSON.stringify(dimension)}`,\n        );\n    }\n\n    return schema;\n};\n"]}
+{"version":3,"sources":["../src/utils.ts"],"names":["extractSchemaFromFactory","factory","dimension","schema","dimensionToSchemaMap","byDimension","Object","values","find","dim","serializeDimensions","base","shape","Error","name","JSON","stringify"],"mappings":";;;;AAOO,IAAMA,wBAAAA,mBAA2B,MAAA,CAAA,CACpCC,OAAAA,EACAC,SAAAA,KAAAA;AAEA,EAAA,MAAMC,MAAAA,GAAAA,CACDF,OAAAA,CAAQG,oBAAAA,CAAqBC,WAAAA,IAC1BC,MAAAA,CAAOC,OAAON,OAAAA,CAAQG,oBAAAA,CAAqBC,WAAW,CAAA,CAAoBG,IAAAA,CACtE,CAAC,CAACC,GAAAA,CAAAA,KAASC,mBAAAA,CAAoBD,GAAAA,CAAAA,KAASC,mBAAAA,CAAoBR,SAAAA,CAAAA,CAAAA,GAC5D,CAAA,CAAA,KACRD,OAAAA,CAAQG,oBAAAA,CAAqBO,IAAAA;AACjC,EAAA,IAAI,CAACR,QAAQS,KAAAA,EAAO;AAChB,IAAA,MAAM,IAAIC,KAAAA,CACN,CAAA,uCAAA,EAA0CZ,OAAAA,CAAQa,IAAI,YAAYC,IAAAA,CAAKC,SAAAA,CAAUd,SAAAA,CAAAA,CAAAA,CAAY,CAAA;AAErG,EAAA;AAEA,EAAA,OAAOC,MAAAA;AACX,CAAA,EAjBwC,0BAAA","file":"G24SMCHK.js","sourcesContent":["import type z from 'zod/v4';\n\nimport type { AdvancedRecord } from '@layerzerolabs/typescript-utils';\n\nimport type { Factory } from './definitions';\nimport { type FactoryDefinition, serializeDimensions } from './definitions';\n\nexport const extractSchemaFromFactory = <Dim extends z.ZodObject>(\n    factory: FactoryDefinition<any, Dim, any, any, any> | Factory<any, any, any, any>,\n    dimension: z.infer<Dim>,\n): z.ZodObject => {\n    const schema =\n        (factory.dimensionToSchemaMap.byDimension &&\n            Object.values(factory.dimensionToSchemaMap.byDimension as AdvancedRecord).find(\n                ([dim]) => serializeDimensions(dim) === serializeDimensions(dimension),\n            )?.[1]) ??\n        factory.dimensionToSchemaMap.base;\n    if (!schema?.shape) {\n        throw new Error(\n            `Couldn't resolve the schema of factory ${factory.name} for dim ${JSON.stringify(dimension)}`,\n        );\n    }\n\n    return schema;\n};\n"]}

package/dist/{3GFGHSFN.js → JV365MVS.js}

@@ -32,5 +32,5 @@ var serializeDimensions = /* @__PURE__ */ __name((dim = {}) => {
 }, "serializeDimensions");
 
 export { FactoryDefinition, ObjectDefinition, serializeDimensions };
-//# sourceMappingURL=3GFGHSFN.js.map
-//# sourceMappingURL=3GFGHSFN.js.map
+//# sourceMappingURL=JV365MVS.js.map
+//# sourceMappingURL=JV365MVS.js.map

package/dist/JV365MVS.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/definitions.ts"],"names":["FactoryDefinition","DependencyNode","dimensions","specialization","dimensionToSchemaMap","getFactory","args","ObjectDefinition","schema","serializeDimensions","dim","Object","keys","length","entries","sort","map","dimName","dimVal","join"],"mappings":";;;AA+HO,IAAMA,iBAAAA,GAAN,cAMGC,cAAAA,CAAAA;EAjIV;;;AAkIoBC,EAAAA,UAAAA;AACAC,EAAAA,cAAAA;AACAC,EAAAA,oBAAAA;AACAC,EAAAA,UAAAA;AAChB,EAAA,WAAA,CAAY,EACRH,UAAAA,EACAC,cAAAA,EACAC,sBACAC,UAAAA,EACA,GAAGC,MAAAA,EAMmE;AACtE,IAAA,KAAA,CAAMA,IAAAA,CAAAA;AACN,IAAA,IAAA,CAAKJ,UAAAA,GAAaA,UAAAA;AAClB,IAAA,IAAA,CAAKC,cAAAA,GAAiBA,cAAAA;AACtB,IAAA,IAAA,CAAKC,oBAAAA,GAAuBA,oBAAAA;AAC5B,IAAA,IAAA,CAAKC,UAAAA,GAAaA,UAAAA;AACtB,EAAA;AACJ;AAaO,IAAeE,gBAAAA,GAAf,cAIGN,cAAAA,CAAAA;EAzKV;;;AA0KoBO,EAAAA,MAAAA;AAEhB,EAAA,WAAA,CAAY,EACRA,MAAAA,EACA,GAAGF,IAAAA,EAAAA,EAGmE;AACtE,IAAA,KAAA,CAAMA,IAAAA,CAAAA;AACN,IAAA,IAAA,CAAKE,MAAAA,GAASA,MAAAA;AAClB,EAAA;AACJ;AA4GO,IAAMC,mBAAAA,mBAAsB,MAAA,CAAA,CAACC,GAAAA,GAAc,EAAC,KAAC;AAChD,EAAA,OAAOC,MAAAA,CAAOC,IAAAA,CAAKF,GAAAA,CAAAA,CAAKG,MAAAA,GAClBF,MAAAA,CAAOG,OAAAA,CAAQJ,GAAAA,CAAAA,CACVK,IAAAA,EAAI,CACJC,GAAAA,CAAI,CAAC,CAACC,OAAAA,EAASC,MAAAA,CAAAA,KAAY,CAAA,EAAGD,OAAAA,CAAAA,CAAAA,EAAWC,MAAAA,CAAAA,CAAAA,EAAU,EAAA,CAAA,CACnDC,IAAAA,CAAK,GAAA,CAAA,GACV,OAAA;AACV,CAAA,EAPmC,qBAAA","file":"JV365MVS.js","sourcesContent":["import type { z } from 'zod/v4';\n\nimport type { FunctionPointer } from '@layerzerolabs/common-utils';\nimport type { Dependencies } from '@layerzerolabs/dependency-graph';\nimport { DependencyNode } from '@layerzerolabs/dependency-graph';\nimport type {\n    AdvancedRecord,\n    AdvancedRecordLookup,\n    Merge,\n    MethodNameOf,\n    RemoveNever,\n    UnionToIntersection,\n} from '@layerzerolabs/typescript-utils';\n\nexport type DimensionToSchemaMap<DimConstraint extends object = object> = {\n    byDimension?: AdvancedRecord<DimConstraint, z.ZodType>;\n    base: z.ZodType;\n};\n\nexport type FactorySpecialization<DMap extends DimensionToSchemaMap = DimensionToSchemaMap> = {\n    spec: z.ZodObject<any>;\n    exempt: readonly MethodNameOf<GetSupersetOfModelsFromSchema<DMap>>[];\n};\n\nexport type WithInjectedSpecialization<T, Specialization extends FactorySpecialization<any>> = [\n    {},\n] extends [z.infer<Specialization['spec']>]\n    ? T\n    : {\n          [K in keyof T]: K extends Specialization['exempt'][number]\n              ? T[K]\n              : T[K] extends (...args: infer A) => infer R\n                ? (specialization: z.infer<Specialization['spec']>, ...args: A) => R\n                : T[K];\n      };\n\nexport type WithSpecializeMethod<WithInjection, WithoutInjection, S> = {} extends S\n    ? WithoutInjection\n    : WithInjection extends (...args: infer Args) => infer Ret\n      ? (...args: Args) => Ret\n      : WithInjection & {\n            specialize: (specialization: S) => WithoutInjection;\n        };\n\nexport type GetModelFromSchema<DMap extends DimensionToSchemaMap, Dim> =\n    AdvancedRecordLookup<DMap['byDimension'], Dim> extends never\n        ? z.infer<DMap['base']>\n        : Merge<z.infer<DMap['base']>, z.infer<AdvancedRecordLookup<DMap['byDimension'], Dim>>>;\n\nexport type GetSupersetOfModelsFromSchema<DMap extends DimensionToSchemaMap> = UnionToIntersection<\n    {\n        [Key in keyof DMap['byDimension']]: DMap['byDimension'][Key] extends [any, any]\n            ? z.infer<DMap['byDimension'][Key][1]>\n            : never;\n    }[keyof DMap['byDimension']]\n> &\n    z.infer<DMap['base']>;\n\ntype GetImplFunctionWithConditionalOptionalDim<Dim, Return> = {} extends Dim\n    ? (dim?: Dim) => Return\n    : (dim: Dim) => Return;\n\ntype GetImplOverloads<\n    Dim extends z.ZodObject<any>,\n    Specialization extends FactorySpecialization<DMap>,\n    DMap extends DimensionToSchemaMap<z.infer<Dim>>,\n> = UnionToIntersection<\n    | {\n          [I in keyof DMap['byDimension']]: DMap['byDimension'][I] extends readonly [infer K, any]\n              ? {\n                    getImpl: GetImplFunctionWithConditionalOptionalDim<\n                        K,\n                        WithSpecializeMethod<\n                            WithInjectedSpecialization<GetModelFromSchema<DMap, K>, Specialization>,\n                            GetModelFromSchema<DMap, K>,\n                            z.infer<Specialization['spec']>\n                        >\n                    >;\n                }\n              : never;\n      }[keyof DMap['byDimension']]\n    | {\n          getImpl: GetImplFunctionWithConditionalOptionalDim<\n              z.infer<Dim>,\n              WithSpecializeMethod<\n                  WithInjectedSpecialization<z.infer<DMap['base']>, Specialization>,\n                  z.infer<DMap['base']>,\n                  z.infer<Specialization['spec']>\n              >\n          >;\n      }\n>;\n\nexport type Factory<\n    _Dependencies extends Dependencies,\n    Dim extends z.ZodObject<any>,\n    Specialization extends FactorySpecialization<DMap>,\n    DMap extends DimensionToSchemaMap<z.infer<Dim>>,\n> = {\n    name: string;\n    implKeys: string[];\n    dimensionToSchemaMap: DMap;\n} & GetImplOverloads<Dim, Specialization, DMap>;\n\nexport type GetFactory<\n    _Dependencies extends Dependencies,\n    Dim extends z.ZodObject<any>,\n    Specialization extends FactorySpecialization<DMap>,\n    DMap extends DimensionToSchemaMap<z.infer<Dim>>,\n> = () =>\n    | Factory<_Dependencies, Dim, Specialization, DMap>\n    | Promise<Factory<_Dependencies, Dim, Specialization, DMap>>;\n\n/**\n * <!-- anchor:FactoryDefinition -->\n * Factory definitions are a type of dependency node that shall be resolved to a *factory*.\n * A factory is an object that provides a getImpl method which accepts some parameters `dim`,\n * and returns some object `getImplMetadata.getModel(dim)`.\n * That is, a factory definition is given by the set of parameters it uses to get its implementations,\n * and a function defining the schema it will return for each set of parameters.\n * @param name inherited from {@link DependencyNode}\n * @param dependencies inherited from {@link DependencyNode}\n * @param dimensions a Zod schema for the parameters this factory operates on.\n * @param dimensionToSchemaMap A map from dimension objects to the Zod schema for the implementation.\n * @param getFactory a method that should return an object with a `getImpl` method that returns\n * entities adhering to the schema for the corresponding `getModel` call\n */\nexport class FactoryDefinition<\n    Name extends string,\n    Dim extends z.ZodObject<any>,\n    const Specialization extends FactorySpecialization<DMap>,\n    DMap extends DimensionToSchemaMap<z.infer<Dim>>,\n    _Dependencies extends Dependencies,\n> extends DependencyNode<Name, _Dependencies> {\n    public readonly dimensions: Dim;\n    public readonly specialization: Specialization;\n    public readonly dimensionToSchemaMap: DMap;\n    public readonly getFactory: GetFactory<_Dependencies, Dim, Specialization, DMap>;\n    constructor({\n        dimensions,\n        specialization,\n        dimensionToSchemaMap,\n        getFactory,\n        ...args\n    }: {\n        dimensions: Dim;\n        specialization: Specialization;\n        dimensionToSchemaMap: DMap;\n        getFactory: GetFactory<_Dependencies, Dim, Specialization, DMap>;\n    } & ConstructorParameters<typeof DependencyNode<Name, _Dependencies>>[0]) {\n        super(args);\n        this.dimensions = dimensions;\n        this.specialization = specialization;\n        this.dimensionToSchemaMap = dimensionToSchemaMap;\n        this.getFactory = getFactory;\n    }\n}\n\n/**\n * <!-- anchor:ObjectDefinition -->\n * An object definition is a dependency node that refers to some entity\n * matching a given schema. That is, it may be resolved to any entity\n * that adheres to the {@link schema}.\n * The object definition is abstract, as it cannot be meaningfully resolved without\n * additional information. For an example of an object definition, see ReflexiveObjectDefinition or ContextDefinition\n * @param name inherited from {@link DependencyNode}\n * @param dependencies inherited from {@link DependencyNode}\n * @param schema a Zod schema defining the expected resolution for this definition\n */\nexport abstract class ObjectDefinition<\n    Name extends string,\n    Schema extends z.ZodSchema,\n    _Dependencies extends Dependencies,\n> extends DependencyNode<Name, _Dependencies> {\n    public readonly schema: Schema;\n\n    constructor({\n        schema,\n        ...args\n    }: {\n        schema: Schema;\n    } & ConstructorParameters<typeof DependencyNode<Name, _Dependencies>>[0]) {\n        super(args);\n        this.schema = schema;\n    }\n}\n\nexport type Definition<Name extends string> =\n    | FactoryDefinition<Name, any, any, any, any>\n    | ObjectDefinition<Name, any, any>;\n\n/**\n * Infers the expected type of a definition once it has been resolved\n */\nexport type ResolvedDefinition<Definition extends DependencyNode<any, any>> =\n    Definition extends ObjectDefinition<any, infer Schema, any>\n        ? z.infer<Schema>\n        : Definition extends FactoryDefinition<\n                any,\n                infer Dim,\n                infer Specialization,\n                infer DMap,\n                any\n            >\n          ? Factory<Definition['dependencies'], Dim, Specialization, DMap>\n          : Definition extends FactoryDefinition<any, any, any, any, any>\n            ? Factory<\n                  Definition['dependencies'],\n                  Definition['dimensions'],\n                  Definition['specialization'],\n                  Definition['dimensionToSchemaMap']\n              >\n            : unknown;\n\n/**\n * Given a record from string to definition, maps each definition T to ResolvedDefinition<T>. Removes `definition` suffix from name\n */\nexport type ResolvedDefinitionMap<Deps extends Dependencies> = {\n    [Key in keyof Deps as Key extends `${infer Name}Definition` ? Name : Key]: ResolvedDefinition<\n        Deps[Key]\n    >;\n};\n\n/**\n * For some factory definition F and some dimension D s.t. D ⊇ F.dimensions, infers the expected return type of\n * ResolvedDefinition<F>.getImpl(D)\n */\nexport type ResolvedFactoryImplementation<Definition extends DependencyNode<any, any>, Dim> =\n    Definition extends FactoryDefinition<any, any, any, any, any>\n        ? WithSpecializeMethod<\n              WithInjectedSpecialization<\n                  GetModelFromSchema<Definition['dimensionToSchemaMap'], Dim>,\n                  Definition['specialization']\n              >,\n              GetModelFromSchema<Definition['dimensionToSchemaMap'], Dim>,\n              z.infer<Definition['specialization']['spec']>\n          >\n        : never;\n\n/**\n * Given a record from string to definition and some dimension D, maps each definition T to ResolvedFactoryImplementation<T, D>\n */\nexport type ResolvedFactoryImplementationMap<Deps extends Dependencies, Dim> = RemoveNever<{\n    [Key in keyof Deps as Key extends `${infer Name}Definition`\n        ? Name\n        : Key]: ResolvedFactoryImplementation<Deps[Key], Dim>;\n}>;\n\ntype ActivityFactoryContext<\n    _FactoryDefinition extends FactoryDefinition<any, any, any, any, any>,\n    Dim,\n    _PrivateSchemaExtension extends z.ZodObject = z.ZodObject<{}, z.core.$strip>,\n> = {\n    getFunctionPointer: <\n        MethodName extends MethodNameOf<\n            ResolvedFactoryImplementation<_FactoryDefinition, Dim> &\n                WithInjectedSpecialization<\n                    z.infer<_PrivateSchemaExtension>,\n                    _FactoryDefinition['specialization']\n                >\n        >,\n    >(\n        methodName: MethodName,\n    ) => FunctionPointer<\n        (ResolvedFactoryImplementation<_FactoryDefinition, Dim> &\n            WithInjectedSpecialization<\n                z.infer<_PrivateSchemaExtension>,\n                _FactoryDefinition['specialization']\n            >)[MethodName]\n    >;\n};\n\n/**\n * The parameters that shall be received by a factory's implementation getter\n */\nexport type Context<\n    _FactoryDefinition extends FactoryDefinition<any, any, any, any, any>,\n    Dim,\n    _PrivateSchemaExtension extends z.ZodObject = z.ZodObject<{}, z.core.$strip>,\n> = {\n    name: _FactoryDefinition extends FactoryDefinition<infer Name, any, any, any, any>\n        ? Name\n        : never;\n    dependencies: _FactoryDefinition extends FactoryDefinition<any, any, any, any, infer Deps>\n        ? ResolvedDefinitionMap<Deps>\n        : never;\n    dim: Dim;\n    impls: _FactoryDefinition extends FactoryDefinition<any, any, any, any, infer Deps>\n        ? ResolvedFactoryImplementationMap<Deps, Dim>\n        : never;\n    self: ResolvedFactoryImplementation<_FactoryDefinition, Dim> & z.infer<_PrivateSchemaExtension>;\n} & ActivityFactoryContext<_FactoryDefinition, Dim, _PrivateSchemaExtension>;\n\nexport const serializeDimensions = (dim: object = {}) => {\n    return Object.keys(dim).length\n        ? Object.entries(dim)\n              .sort()\n              .map(([dimName, dimVal]) => `${dimName}_${dimVal}`, '')\n              .join('&')\n        : '_base';\n};\n"]}

package/dist/{GD77KZDY.cjs → U3E5EB56.cjs}

@@ -36,5 +36,5 @@ var serializeDimensions = /* @__PURE__ */ YJF4D23A_cjs.__name((dim = {}) => {
 exports.FactoryDefinition = FactoryDefinition;
 exports.ObjectDefinition = ObjectDefinition;
 exports.serializeDimensions = serializeDimensions;
-//# sourceMappingURL=GD77KZDY.cjs.map
-//# sourceMappingURL=GD77KZDY.cjs.map
+//# sourceMappingURL=U3E5EB56.cjs.map
+//# sourceMappingURL=U3E5EB56.cjs.map

package/dist/U3E5EB56.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/definitions.ts"],"names":["FactoryDefinition","DependencyNode","dimensions","specialization","dimensionToSchemaMap","getFactory","args","ObjectDefinition","schema","serializeDimensions","__name","dim","Object","keys","length","entries","sort","map","dimName","dimVal","join"],"mappings":";;;;;AA+HO,IAAMA,iBAAAA,GAAN,cAMGC,8BAAAA,CAAAA;EAjIV;;;AAkIoBC,EAAAA,UAAAA;AACAC,EAAAA,cAAAA;AACAC,EAAAA,oBAAAA;AACAC,EAAAA,UAAAA;AAChB,EAAA,WAAA,CAAY,EACRH,UAAAA,EACAC,cAAAA,EACAC,sBACAC,UAAAA,EACA,GAAGC,MAAAA,EAMmE;AACtE,IAAA,KAAA,CAAMA,IAAAA,CAAAA;AACN,IAAA,IAAA,CAAKJ,UAAAA,GAAaA,UAAAA;AAClB,IAAA,IAAA,CAAKC,cAAAA,GAAiBA,cAAAA;AACtB,IAAA,IAAA,CAAKC,oBAAAA,GAAuBA,oBAAAA;AAC5B,IAAA,IAAA,CAAKC,UAAAA,GAAaA,UAAAA;AACtB,EAAA;AACJ;AAaO,IAAeE,gBAAAA,GAAf,cAIGN,8BAAAA,CAAAA;EAzKV;;;AA0KoBO,EAAAA,MAAAA;AAEhB,EAAA,WAAA,CAAY,EACRA,MAAAA,EACA,GAAGF,IAAAA,EAAAA,EAGmE;AACtE,IAAA,KAAA,CAAMA,IAAAA,CAAAA;AACN,IAAA,IAAA,CAAKE,MAAAA,GAASA,MAAAA;AAClB,EAAA;AACJ;AA4GO,IAAMC,mBAAAA,mBAAsBC,mBAAA,CAAA,CAACC,GAAAA,GAAc,EAAC,KAAC;AAChD,EAAA,OAAOC,MAAAA,CAAOC,IAAAA,CAAKF,GAAAA,CAAAA,CAAKG,MAAAA,GAClBF,MAAAA,CAAOG,OAAAA,CAAQJ,GAAAA,CAAAA,CACVK,IAAAA,EAAI,CACJC,GAAAA,CAAI,CAAC,CAACC,OAAAA,EAASC,MAAAA,CAAAA,KAAY,CAAA,EAAGD,OAAAA,CAAAA,CAAAA,EAAWC,MAAAA,CAAAA,CAAAA,EAAU,EAAA,CAAA,CACnDC,IAAAA,CAAK,GAAA,CAAA,GACV,OAAA;AACV,CAAA,EAPmC,qBAAA","file":"U3E5EB56.cjs","sourcesContent":["import type { z } from 'zod/v4';\n\nimport type { FunctionPointer } from '@layerzerolabs/common-utils';\nimport type { Dependencies } from '@layerzerolabs/dependency-graph';\nimport { DependencyNode } from '@layerzerolabs/dependency-graph';\nimport type {\n    AdvancedRecord,\n    AdvancedRecordLookup,\n    Merge,\n    MethodNameOf,\n    RemoveNever,\n    UnionToIntersection,\n} from '@layerzerolabs/typescript-utils';\n\nexport type DimensionToSchemaMap<DimConstraint extends object = object> = {\n    byDimension?: AdvancedRecord<DimConstraint, z.ZodType>;\n    base: z.ZodType;\n};\n\nexport type FactorySpecialization<DMap extends DimensionToSchemaMap = DimensionToSchemaMap> = {\n    spec: z.ZodObject<any>;\n    exempt: readonly MethodNameOf<GetSupersetOfModelsFromSchema<DMap>>[];\n};\n\nexport type WithInjectedSpecialization<T, Specialization extends FactorySpecialization<any>> = [\n    {},\n] extends [z.infer<Specialization['spec']>]\n    ? T\n    : {\n          [K in keyof T]: K extends Specialization['exempt'][number]\n              ? T[K]\n              : T[K] extends (...args: infer A) => infer R\n                ? (specialization: z.infer<Specialization['spec']>, ...args: A) => R\n                : T[K];\n      };\n\nexport type WithSpecializeMethod<WithInjection, WithoutInjection, S> = {} extends S\n    ? WithoutInjection\n    : WithInjection extends (...args: infer Args) => infer Ret\n      ? (...args: Args) => Ret\n      : WithInjection & {\n            specialize: (specialization: S) => WithoutInjection;\n        };\n\nexport type GetModelFromSchema<DMap extends DimensionToSchemaMap, Dim> =\n    AdvancedRecordLookup<DMap['byDimension'], Dim> extends never\n        ? z.infer<DMap['base']>\n        : Merge<z.infer<DMap['base']>, z.infer<AdvancedRecordLookup<DMap['byDimension'], Dim>>>;\n\nexport type GetSupersetOfModelsFromSchema<DMap extends DimensionToSchemaMap> = UnionToIntersection<\n    {\n        [Key in keyof DMap['byDimension']]: DMap['byDimension'][Key] extends [any, any]\n            ? z.infer<DMap['byDimension'][Key][1]>\n            : never;\n    }[keyof DMap['byDimension']]\n> &\n    z.infer<DMap['base']>;\n\ntype GetImplFunctionWithConditionalOptionalDim<Dim, Return> = {} extends Dim\n    ? (dim?: Dim) => Return\n    : (dim: Dim) => Return;\n\ntype GetImplOverloads<\n    Dim extends z.ZodObject<any>,\n    Specialization extends FactorySpecialization<DMap>,\n    DMap extends DimensionToSchemaMap<z.infer<Dim>>,\n> = UnionToIntersection<\n    | {\n          [I in keyof DMap['byDimension']]: DMap['byDimension'][I] extends readonly [infer K, any]\n              ? {\n                    getImpl: GetImplFunctionWithConditionalOptionalDim<\n                        K,\n                        WithSpecializeMethod<\n                            WithInjectedSpecialization<GetModelFromSchema<DMap, K>, Specialization>,\n                            GetModelFromSchema<DMap, K>,\n                            z.infer<Specialization['spec']>\n                        >\n                    >;\n                }\n              : never;\n      }[keyof DMap['byDimension']]\n    | {\n          getImpl: GetImplFunctionWithConditionalOptionalDim<\n              z.infer<Dim>,\n              WithSpecializeMethod<\n                  WithInjectedSpecialization<z.infer<DMap['base']>, Specialization>,\n                  z.infer<DMap['base']>,\n                  z.infer<Specialization['spec']>\n              >\n          >;\n      }\n>;\n\nexport type Factory<\n    _Dependencies extends Dependencies,\n    Dim extends z.ZodObject<any>,\n    Specialization extends FactorySpecialization<DMap>,\n    DMap extends DimensionToSchemaMap<z.infer<Dim>>,\n> = {\n    name: string;\n    implKeys: string[];\n    dimensionToSchemaMap: DMap;\n} & GetImplOverloads<Dim, Specialization, DMap>;\n\nexport type GetFactory<\n    _Dependencies extends Dependencies,\n    Dim extends z.ZodObject<any>,\n    Specialization extends FactorySpecialization<DMap>,\n    DMap extends DimensionToSchemaMap<z.infer<Dim>>,\n> = () =>\n    | Factory<_Dependencies, Dim, Specialization, DMap>\n    | Promise<Factory<_Dependencies, Dim, Specialization, DMap>>;\n\n/**\n * <!-- anchor:FactoryDefinition -->\n * Factory definitions are a type of dependency node that shall be resolved to a *factory*.\n * A factory is an object that provides a getImpl method which accepts some parameters `dim`,\n * and returns some object `getImplMetadata.getModel(dim)`.\n * That is, a factory definition is given by the set of parameters it uses to get its implementations,\n * and a function defining the schema it will return for each set of parameters.\n * @param name inherited from {@link DependencyNode}\n * @param dependencies inherited from {@link DependencyNode}\n * @param dimensions a Zod schema for the parameters this factory operates on.\n * @param dimensionToSchemaMap A map from dimension objects to the Zod schema for the implementation.\n * @param getFactory a method that should return an object with a `getImpl` method that returns\n * entities adhering to the schema for the corresponding `getModel` call\n */\nexport class FactoryDefinition<\n    Name extends string,\n    Dim extends z.ZodObject<any>,\n    const Specialization extends FactorySpecialization<DMap>,\n    DMap extends DimensionToSchemaMap<z.infer<Dim>>,\n    _Dependencies extends Dependencies,\n> extends DependencyNode<Name, _Dependencies> {\n    public readonly dimensions: Dim;\n    public readonly specialization: Specialization;\n    public readonly dimensionToSchemaMap: DMap;\n    public readonly getFactory: GetFactory<_Dependencies, Dim, Specialization, DMap>;\n    constructor({\n        dimensions,\n        specialization,\n        dimensionToSchemaMap,\n        getFactory,\n        ...args\n    }: {\n        dimensions: Dim;\n        specialization: Specialization;\n        dimensionToSchemaMap: DMap;\n        getFactory: GetFactory<_Dependencies, Dim, Specialization, DMap>;\n    } & ConstructorParameters<typeof DependencyNode<Name, _Dependencies>>[0]) {\n        super(args);\n        this.dimensions = dimensions;\n        this.specialization = specialization;\n        this.dimensionToSchemaMap = dimensionToSchemaMap;\n        this.getFactory = getFactory;\n    }\n}\n\n/**\n * <!-- anchor:ObjectDefinition -->\n * An object definition is a dependency node that refers to some entity\n * matching a given schema. That is, it may be resolved to any entity\n * that adheres to the {@link schema}.\n * The object definition is abstract, as it cannot be meaningfully resolved without\n * additional information. For an example of an object definition, see ReflexiveObjectDefinition or ContextDefinition\n * @param name inherited from {@link DependencyNode}\n * @param dependencies inherited from {@link DependencyNode}\n * @param schema a Zod schema defining the expected resolution for this definition\n */\nexport abstract class ObjectDefinition<\n    Name extends string,\n    Schema extends z.ZodSchema,\n    _Dependencies extends Dependencies,\n> extends DependencyNode<Name, _Dependencies> {\n    public readonly schema: Schema;\n\n    constructor({\n        schema,\n        ...args\n    }: {\n        schema: Schema;\n    } & ConstructorParameters<typeof DependencyNode<Name, _Dependencies>>[0]) {\n        super(args);\n        this.schema = schema;\n    }\n}\n\nexport type Definition<Name extends string> =\n    | FactoryDefinition<Name, any, any, any, any>\n    | ObjectDefinition<Name, any, any>;\n\n/**\n * Infers the expected type of a definition once it has been resolved\n */\nexport type ResolvedDefinition<Definition extends DependencyNode<any, any>> =\n    Definition extends ObjectDefinition<any, infer Schema, any>\n        ? z.infer<Schema>\n        : Definition extends FactoryDefinition<\n                any,\n                infer Dim,\n                infer Specialization,\n                infer DMap,\n                any\n            >\n          ? Factory<Definition['dependencies'], Dim, Specialization, DMap>\n          : Definition extends FactoryDefinition<any, any, any, any, any>\n            ? Factory<\n                  Definition['dependencies'],\n                  Definition['dimensions'],\n                  Definition['specialization'],\n                  Definition['dimensionToSchemaMap']\n              >\n            : unknown;\n\n/**\n * Given a record from string to definition, maps each definition T to ResolvedDefinition<T>. Removes `definition` suffix from name\n */\nexport type ResolvedDefinitionMap<Deps extends Dependencies> = {\n    [Key in keyof Deps as Key extends `${infer Name}Definition` ? Name : Key]: ResolvedDefinition<\n        Deps[Key]\n    >;\n};\n\n/**\n * For some factory definition F and some dimension D s.t. D ⊇ F.dimensions, infers the expected return type of\n * ResolvedDefinition<F>.getImpl(D)\n */\nexport type ResolvedFactoryImplementation<Definition extends DependencyNode<any, any>, Dim> =\n    Definition extends FactoryDefinition<any, any, any, any, any>\n        ? WithSpecializeMethod<\n              WithInjectedSpecialization<\n                  GetModelFromSchema<Definition['dimensionToSchemaMap'], Dim>,\n                  Definition['specialization']\n              >,\n              GetModelFromSchema<Definition['dimensionToSchemaMap'], Dim>,\n              z.infer<Definition['specialization']['spec']>\n          >\n        : never;\n\n/**\n * Given a record from string to definition and some dimension D, maps each definition T to ResolvedFactoryImplementation<T, D>\n */\nexport type ResolvedFactoryImplementationMap<Deps extends Dependencies, Dim> = RemoveNever<{\n    [Key in keyof Deps as Key extends `${infer Name}Definition`\n        ? Name\n        : Key]: ResolvedFactoryImplementation<Deps[Key], Dim>;\n}>;\n\ntype ActivityFactoryContext<\n    _FactoryDefinition extends FactoryDefinition<any, any, any, any, any>,\n    Dim,\n    _PrivateSchemaExtension extends z.ZodObject = z.ZodObject<{}, z.core.$strip>,\n> = {\n    getFunctionPointer: <\n        MethodName extends MethodNameOf<\n            ResolvedFactoryImplementation<_FactoryDefinition, Dim> &\n                WithInjectedSpecialization<\n                    z.infer<_PrivateSchemaExtension>,\n                    _FactoryDefinition['specialization']\n                >\n        >,\n    >(\n        methodName: MethodName,\n    ) => FunctionPointer<\n        (ResolvedFactoryImplementation<_FactoryDefinition, Dim> &\n            WithInjectedSpecialization<\n                z.infer<_PrivateSchemaExtension>,\n                _FactoryDefinition['specialization']\n            >)[MethodName]\n    >;\n};\n\n/**\n * The parameters that shall be received by a factory's implementation getter\n */\nexport type Context<\n    _FactoryDefinition extends FactoryDefinition<any, any, any, any, any>,\n    Dim,\n    _PrivateSchemaExtension extends z.ZodObject = z.ZodObject<{}, z.core.$strip>,\n> = {\n    name: _FactoryDefinition extends FactoryDefinition<infer Name, any, any, any, any>\n        ? Name\n        : never;\n    dependencies: _FactoryDefinition extends FactoryDefinition<any, any, any, any, infer Deps>\n        ? ResolvedDefinitionMap<Deps>\n        : never;\n    dim: Dim;\n    impls: _FactoryDefinition extends FactoryDefinition<any, any, any, any, infer Deps>\n        ? ResolvedFactoryImplementationMap<Deps, Dim>\n        : never;\n    self: ResolvedFactoryImplementation<_FactoryDefinition, Dim> & z.infer<_PrivateSchemaExtension>;\n} & ActivityFactoryContext<_FactoryDefinition, Dim, _PrivateSchemaExtension>;\n\nexport const serializeDimensions = (dim: object = {}) => {\n    return Object.keys(dim).length\n        ? Object.entries(dim)\n              .sort()\n              .map(([dimName, dimVal]) => `${dimName}_${dimVal}`, '')\n              .join('&')\n        : '_base';\n};\n"]}

package/dist/{BJOVDE43.cjs → ZSYU3OBT.cjs}

@@ -1,11 +1,11 @@
 'use strict';
 
-var GD77KZDY_cjs = require('./GD77KZDY.cjs');
+var U3E5EB56_cjs = require('./U3E5EB56.cjs');
 var YJF4D23A_cjs = require('./YJF4D23A.cjs');
 
 // src/utils.ts
 var extractSchemaFromFactory = /* @__PURE__ */ YJF4D23A_cjs.__name((factory, dimension) => {
-  const schema = (factory.dimensionToSchemaMap.byDimension && Object.values(factory.dimensionToSchemaMap.byDimension).find(([dim]) => GD77KZDY_cjs.serializeDimensions(dim) === GD77KZDY_cjs.serializeDimensions(dimension))?.[1]) ?? factory.dimensionToSchemaMap.base;
+  const schema = (factory.dimensionToSchemaMap.byDimension && Object.values(factory.dimensionToSchemaMap.byDimension).find(([dim]) => U3E5EB56_cjs.serializeDimensions(dim) === U3E5EB56_cjs.serializeDimensions(dimension))?.[1]) ?? factory.dimensionToSchemaMap.base;
   if (!schema?.shape) {
     throw new Error(`Couldn't resolve the schema of factory ${factory.name} for dim ${JSON.stringify(dimension)}`);
   }
@@ -13,5 +13,5 @@ var extractSchemaFromFactory = /* @__PURE__ */ YJF4D23A_cjs.__name((factory, dim
 }, "extractSchemaFromFactory");
 
 exports.extractSchemaFromFactory = extractSchemaFromFactory;
-//# sourceMappingURL=BJOVDE43.cjs.map
-//# sourceMappingURL=BJOVDE43.cjs.map
+//# sourceMappingURL=ZSYU3OBT.cjs.map
+//# sourceMappingURL=ZSYU3OBT.cjs.map

package/dist/{BJOVDE43.cjs.map → ZSYU3OBT.cjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/utils.ts"],"names":["extractSchemaFromFactory","__name","factory","dimension","schema","dimensionToSchemaMap","byDimension","Object","values","find","dim","serializeDimensions","base","shape","Error","name","JSON","stringify"],"mappings":";;;;;;AAOO,IAAMA,wBAAAA,mBAA2BC,mBAAA,CAAA,CACpCC,OAAAA,EACAC,SAAAA,KAAAA;AAEA,EAAA,MAAMC,MAAAA,GAAAA,CACDF,OAAAA,CAAQG,oBAAAA,CAAqBC,WAAAA,IAC1BC,MAAAA,CAAOC,OAAON,OAAAA,CAAQG,oBAAAA,CAAqBC,WAAW,CAAA,CAAoBG,IAAAA,CACtE,CAAC,CAACC,GAAAA,CAAAA,KAASC,gCAAAA,CAAoBD,GAAAA,CAAAA,KAASC,gCAAAA,CAAoBR,SAAAA,CAAAA,CAAAA,GAC5D,CAAA,CAAA,KACRD,OAAAA,CAAQG,oBAAAA,CAAqBO,IAAAA;AACjC,EAAA,IAAI,CAACR,QAAQS,KAAAA,EAAO;AAChB,IAAA,MAAM,IAAIC,KAAAA,CACN,CAAA,uCAAA,EAA0CZ,OAAAA,CAAQa,IAAI,YAAYC,IAAAA,CAAKC,SAAAA,CAAUd,SAAAA,CAAAA,CAAAA,CAAY,CAAA;AAErG,EAAA;AAEA,EAAA,OAAOC,MAAAA;AACX,CAAA,EAjBwC,0BAAA","file":"BJOVDE43.cjs","sourcesContent":["import type z from 'zod/v4';\n\nimport type { AdvancedRecord } from '@layerzerolabs/typescript-utils';\n\nimport type { Factory } from './definitions';\nimport { type FactoryDefinition, serializeDimensions } from './definitions';\n\nexport const extractSchemaFromFactory = <Dim extends z.ZodObject>(\n    factory: FactoryDefinition<any, Dim, any, any, any> | Factory<any, any, any, any>,\n    dimension: z.infer<Dim>,\n): z.ZodObject => {\n    const schema =\n        (factory.dimensionToSchemaMap.byDimension &&\n            Object.values(factory.dimensionToSchemaMap.byDimension as AdvancedRecord).find(\n                ([dim]) => serializeDimensions(dim) === serializeDimensions(dimension),\n            )?.[1]) ??\n        factory.dimensionToSchemaMap.base;\n    if (!schema?.shape) {\n        throw new Error(\n            `Couldn't resolve the schema of factory ${factory.name} for dim ${JSON.stringify(dimension)}`,\n        );\n    }\n\n    return schema;\n};\n"]}
+{"version":3,"sources":["../src/utils.ts"],"names":["extractSchemaFromFactory","__name","factory","dimension","schema","dimensionToSchemaMap","byDimension","Object","values","find","dim","serializeDimensions","base","shape","Error","name","JSON","stringify"],"mappings":";;;;;;AAOO,IAAMA,wBAAAA,mBAA2BC,mBAAA,CAAA,CACpCC,OAAAA,EACAC,SAAAA,KAAAA;AAEA,EAAA,MAAMC,MAAAA,GAAAA,CACDF,OAAAA,CAAQG,oBAAAA,CAAqBC,WAAAA,IAC1BC,MAAAA,CAAOC,OAAON,OAAAA,CAAQG,oBAAAA,CAAqBC,WAAW,CAAA,CAAoBG,IAAAA,CACtE,CAAC,CAACC,GAAAA,CAAAA,KAASC,gCAAAA,CAAoBD,GAAAA,CAAAA,KAASC,gCAAAA,CAAoBR,SAAAA,CAAAA,CAAAA,GAC5D,CAAA,CAAA,KACRD,OAAAA,CAAQG,oBAAAA,CAAqBO,IAAAA;AACjC,EAAA,IAAI,CAACR,QAAQS,KAAAA,EAAO;AAChB,IAAA,MAAM,IAAIC,KAAAA,CACN,CAAA,uCAAA,EAA0CZ,OAAAA,CAAQa,IAAI,YAAYC,IAAAA,CAAKC,SAAAA,CAAUd,SAAAA,CAAAA,CAAAA,CAAY,CAAA;AAErG,EAAA;AAEA,EAAA,OAAOC,MAAAA;AACX,CAAA,EAjBwC,0BAAA","file":"ZSYU3OBT.cjs","sourcesContent":["import type z from 'zod/v4';\n\nimport type { AdvancedRecord } from '@layerzerolabs/typescript-utils';\n\nimport type { Factory } from './definitions';\nimport { type FactoryDefinition, serializeDimensions } from './definitions';\n\nexport const extractSchemaFromFactory = <Dim extends z.ZodObject>(\n    factory: FactoryDefinition<any, Dim, any, any, any> | Factory<any, any, any, any>,\n    dimension: z.infer<Dim>,\n): z.ZodObject => {\n    const schema =\n        (factory.dimensionToSchemaMap.byDimension &&\n            Object.values(factory.dimensionToSchemaMap.byDimension as AdvancedRecord).find(\n                ([dim]) => serializeDimensions(dim) === serializeDimensions(dimension),\n            )?.[1]) ??\n        factory.dimensionToSchemaMap.base;\n    if (!schema?.shape) {\n        throw new Error(\n            `Couldn't resolve the schema of factory ${factory.name} for dim ${JSON.stringify(dimension)}`,\n        );\n    }\n\n    return schema;\n};\n"]}

package/dist/definitions.cjs

@@ -1,21 +1,21 @@
 'use strict';
 
-var GD77KZDY_cjs = require('./GD77KZDY.cjs');
+var U3E5EB56_cjs = require('./U3E5EB56.cjs');
 require('./YJF4D23A.cjs');
 
 
 
 Object.defineProperty(exports, "FactoryDefinition", {
   enumerable: true,
-  get: function () { return GD77KZDY_cjs.FactoryDefinition; }
+  get: function () { return U3E5EB56_cjs.FactoryDefinition; }
 });
 Object.defineProperty(exports, "ObjectDefinition", {
   enumerable: true,
-  get: function () { return GD77KZDY_cjs.ObjectDefinition; }
+  get: function () { return U3E5EB56_cjs.ObjectDefinition; }
 });
 Object.defineProperty(exports, "serializeDimensions", {
   enumerable: true,
-  get: function () { return GD77KZDY_cjs.serializeDimensions; }
+  get: function () { return U3E5EB56_cjs.serializeDimensions; }
 });
 //# sourceMappingURL=definitions.cjs.map
 //# sourceMappingURL=definitions.cjs.map

package/dist/definitions.d.ts

@@ -9,7 +9,7 @@ export type DimensionToSchemaMap<DimConstraint extends object = object> = {
 };
 export type FactorySpecialization<DMap extends DimensionToSchemaMap = DimensionToSchemaMap> = {
     spec: z.ZodObject<any>;
-    exempt: readonly (keyof GetSupersetOfModelsFromSchema<DMap>)[];
+    exempt: readonly MethodNameOf<GetSupersetOfModelsFromSchema<DMap>>[];
 };
 export type WithInjectedSpecialization<T, Specialization extends FactorySpecialization<any>> = [
     {}
@@ -86,10 +86,10 @@ export type Definition<Name extends string> = FactoryDefinition<Name, any, any,
  */
 export type ResolvedDefinition<Definition extends DependencyNode<any, any>> = Definition extends ObjectDefinition<any, infer Schema, any> ? z.infer<Schema> : Definition extends FactoryDefinition<any, infer Dim, infer Specialization, infer DMap, any> ? Factory<Definition['dependencies'], Dim, Specialization, DMap> : Definition extends FactoryDefinition<any, any, any, any, any> ? Factory<Definition['dependencies'], Definition['dimensions'], Definition['specialization'], Definition['dimensionToSchemaMap']> : unknown;
 /**
- * Given a record from string to definition, maps each definition T to ResolvedDefinition<T>
+ * Given a record from string to definition, maps each definition T to ResolvedDefinition<T>. Removes `definition` suffix from name
  */
 export type ResolvedDefinitionMap<Deps extends Dependencies> = {
-    [Key in keyof Deps]: ResolvedDefinition<Deps[Key]>;
+    [Key in keyof Deps as Key extends `${infer Name}Definition` ? Name : Key]: ResolvedDefinition<Deps[Key]>;
 };
 /**
  * For some factory definition F and some dimension D s.t. D ⊇ F.dimensions, infers the expected return type of
@@ -100,21 +100,21 @@ export type ResolvedFactoryImplementation<Definition extends DependencyNode<any,
  * Given a record from string to definition and some dimension D, maps each definition T to ResolvedFactoryImplementation<T, D>
  */
 export type ResolvedFactoryImplementationMap<Deps extends Dependencies, Dim> = RemoveNever<{
-    [Key in keyof Deps]: ResolvedFactoryImplementation<Deps[Key], Dim>;
+    [Key in keyof Deps as Key extends `${infer Name}Definition` ? Name : Key]: ResolvedFactoryImplementation<Deps[Key], Dim>;
 }>;
-type ActivityFactoryContext<_FactoryDefinition extends FactoryDefinition<any, any, any, any, any>, Dim> = {
-    getFunctionPointer: <MethodName extends MethodNameOf<ResolvedFactoryImplementation<_FactoryDefinition, Dim>>>(methodName: MethodName) => FunctionPointer<ResolvedFactoryImplementation<_FactoryDefinition, Dim>[MethodName]>;
+type ActivityFactoryContext<_FactoryDefinition extends FactoryDefinition<any, any, any, any, any>, Dim, _PrivateSchemaExtension extends z.ZodObject = z.ZodObject<{}, z.core.$strip>> = {
+    getFunctionPointer: <MethodName extends MethodNameOf<ResolvedFactoryImplementation<_FactoryDefinition, Dim> & WithInjectedSpecialization<z.infer<_PrivateSchemaExtension>, _FactoryDefinition['specialization']>>>(methodName: MethodName) => FunctionPointer<(ResolvedFactoryImplementation<_FactoryDefinition, Dim> & WithInjectedSpecialization<z.infer<_PrivateSchemaExtension>, _FactoryDefinition['specialization']>)[MethodName]>;
 };
 /**
  * The parameters that shall be received by a factory's implementation getter
  */
-export type Context<_FactoryDefinition extends FactoryDefinition<any, any, any, any, any>, Dim> = {
+export type Context<_FactoryDefinition extends FactoryDefinition<any, any, any, any, any>, Dim, _PrivateSchemaExtension extends z.ZodObject = z.ZodObject<{}, z.core.$strip>> = {
     name: _FactoryDefinition extends FactoryDefinition<infer Name, any, any, any, any> ? Name : never;
     dependencies: _FactoryDefinition extends FactoryDefinition<any, any, any, any, infer Deps> ? ResolvedDefinitionMap<Deps> : never;
     dim: Dim;
     impls: _FactoryDefinition extends FactoryDefinition<any, any, any, any, infer Deps> ? ResolvedFactoryImplementationMap<Deps, Dim> : never;
-    self: ResolvedFactoryImplementation<_FactoryDefinition, Dim>;
-} & ActivityFactoryContext<_FactoryDefinition, Dim>;
+    self: ResolvedFactoryImplementation<_FactoryDefinition, Dim> & z.infer<_PrivateSchemaExtension>;
+} & ActivityFactoryContext<_FactoryDefinition, Dim, _PrivateSchemaExtension>;
 export declare const serializeDimensions: (dim?: object) => string;
 export {};
 //# sourceMappingURL=definitions.d.ts.map

package/dist/definitions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../src/definitions.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../src/definitions.ts"],"names":[],"mappings":"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"}

package/dist/definitions.js

@@ -1,4 +1,4 @@
-export { FactoryDefinition, ObjectDefinition, serializeDimensions } from './3GFGHSFN.js';
+export { FactoryDefinition, ObjectDefinition, serializeDimensions } from './JV365MVS.js';
 import './VUOMXK5T.js';
 //# sourceMappingURL=definitions.js.map
 //# sourceMappingURL=definitions.js.map

package/dist/index.cjs

@@ -1,9 +1,9 @@
 'use strict';
 
 var JKTGUQY4_cjs = require('./JKTGUQY4.cjs');
-var OLE2MTBK_cjs = require('./OLE2MTBK.cjs');
-var BJOVDE43_cjs = require('./BJOVDE43.cjs');
-var GD77KZDY_cjs = require('./GD77KZDY.cjs');
+var EVDGRGJ5_cjs = require('./EVDGRGJ5.cjs');
+var ZSYU3OBT_cjs = require('./ZSYU3OBT.cjs');
+var U3E5EB56_cjs = require('./U3E5EB56.cjs');
 require('./YJF4D23A.cjs');
 
 
@@ -14,23 +14,23 @@ Object.defineProperty(exports, "DependencyStore", {
 });
 Object.defineProperty(exports, "RegistrarBuilder", {
   enumerable: true,
-  get: function () { return OLE2MTBK_cjs.RegistrarBuilder; }
+  get: function () { return EVDGRGJ5_cjs.RegistrarBuilder; }
 });
 Object.defineProperty(exports, "extractSchemaFromFactory", {
   enumerable: true,
-  get: function () { return BJOVDE43_cjs.extractSchemaFromFactory; }
+  get: function () { return ZSYU3OBT_cjs.extractSchemaFromFactory; }
 });
 Object.defineProperty(exports, "FactoryDefinition", {
   enumerable: true,
-  get: function () { return GD77KZDY_cjs.FactoryDefinition; }
+  get: function () { return U3E5EB56_cjs.FactoryDefinition; }
 });
 Object.defineProperty(exports, "ObjectDefinition", {
   enumerable: true,
-  get: function () { return GD77KZDY_cjs.ObjectDefinition; }
+  get: function () { return U3E5EB56_cjs.ObjectDefinition; }
 });
 Object.defineProperty(exports, "serializeDimensions", {
   enumerable: true,
-  get: function () { return GD77KZDY_cjs.serializeDimensions; }
+  get: function () { return U3E5EB56_cjs.serializeDimensions; }
 });
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map

package/dist/index.js

@@ -1,7 +1,7 @@
 export { DependencyStore } from './JJBD65HU.js';
-export { RegistrarBuilder } from './RGGHMCTO.js';
-export { extractSchemaFromFactory } from './P5NNX2LK.js';
-export { FactoryDefinition, ObjectDefinition, serializeDimensions } from './3GFGHSFN.js';
+export { RegistrarBuilder } from './6D5TVHOU.js';
+export { extractSchemaFromFactory } from './G24SMCHK.js';
+export { FactoryDefinition, ObjectDefinition, serializeDimensions } from './JV365MVS.js';
 import './VUOMXK5T.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/registrarBuilder.cjs

@@ -1,13 +1,13 @@
 'use strict';
 
-var OLE2MTBK_cjs = require('./OLE2MTBK.cjs');
+var EVDGRGJ5_cjs = require('./EVDGRGJ5.cjs');
 require('./YJF4D23A.cjs');
 
 
 
 Object.defineProperty(exports, "RegistrarBuilder", {
   enumerable: true,
-  get: function () { return OLE2MTBK_cjs.RegistrarBuilder; }
+  get: function () { return EVDGRGJ5_cjs.RegistrarBuilder; }
 });
 //# sourceMappingURL=registrarBuilder.cjs.map
 //# sourceMappingURL=registrarBuilder.cjs.map

package/dist/registrarBuilder.d.ts

@@ -34,7 +34,7 @@ export declare class RegistrarBuilder<_ReturnTypes> {
      * @param identifier
      * @param fn
      */
-    addClassHandler<Identifier extends string, _NodeClass extends NodeClass, Function extends (node: InstanceType<_NodeClass>, ancestry: DependencyNode[]) => any>(nodeClass: _NodeClass, identifier: Identifier, fn: Function): RegistrarBuilder<_ReturnTypes & { [K in Identifier]: {
+    addClassHandler<Identifier extends string, _NodeClass extends NodeClass, Function extends (node: InstanceType<_NodeClass>, ancestry: DependencyNode[]) => any>(nodeClass: _NodeClass, identifier: Identifier, fn: Function): RegistrarBuilder<_ReturnTypes & { [_K in Identifier]: {
         [nodeName: string]: Awaited<ReturnType<Function>>;
     }; }>;
     /**

package/dist/registrarBuilder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registrarBuilder.d.ts","sourceRoot":"","sources":["../src/registrarBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACpD,YAAY,EAAE,SAAS,EAAE,CAAC;AAG1B,KAAK,SAAS,GAAG,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,cAAc,CAAC;AACxD,KAAK,iBAAiB,GAAG,QAAQ,MAAM,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,cAAc,CAAC;AAEzE;;;;;;;;;;;;GAYG;AACH,qBAAa,gBAAgB,CAAC,YAAY;IACtC,SAAS,CAAC,cAAc,EAAE,CAAC,IAAI,EAAE,cAAc,EAAE,QAAQ,EAAE,cAAc,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;;IAS7F,SAAS,CAAC,aAAa,EAAE;QACrB,SAAS,EAAE,iBAAiB,CAAC;QAC7B,UAAU,EAAE,MAAM,CAAC;QACnB,EAAE,EAAE,CAAC,IAAI,EAAE,cAAc,EAAE,QAAQ,EAAE,cAAc,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;KAC1E,EAAE,CAAM;IAET,SAAS,CAAC,YAAY,EAAE;QACpB,aAAa,EAAE,iBAAiB,CAAC;QACjC,SAAS,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,cAAc,CAAC;KACvD,EAAE,CAAM;IAET;;;;;OAKG;IACI,eAAe,CAClB,UAAU,SAAS,MAAM,EACzB,UAAU,SAAS,SAAS,EAC5B,QAAQ,SAAS,CAAC,IAAI,EAAE,YAAY,CAAC,UAAU,CAAC,EAAE,QAAQ,EAAE,cAAc,EAAE,KAAK,GAAG,EACtF,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,EAAE,EAAE,QAAQ,sCAmBxC,CAAC;;;IAoCtB;;;;;;;;;;;;OAYG;IACI,aAAa,CAAC,aAAa,SAAS,iBAAiB,EACxD,aAAa,EAAE,aAAa,EAC5B,SAAS,EAAE,CAAC,gBAAgB,EAAE,YAAY,CAAC,aAAa,CAAC,KAAK,cAAc;IAuChF;;;;OAIG;IACI,UAAU,CAAC,EAAE,EAAE,CAAC,IAAI,EAAE,cAAc,EAAE,QAAQ,EAAE,cAAc,EAAE,KAAK,GAAG;IAKxE,KAAK,IAAI,SAAS,CAAC,YAAY,CAAC;CA8B1C"}
+{"version":3,"file":"registrarBuilder.d.ts","sourceRoot":"","sources":["../src/registrarBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD,YAAY,EAAE,SAAS,EAAE,CAAC;AAE1B,KAAK,SAAS,GAAG,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,cAAc,CAAC;AACxD,KAAK,iBAAiB,GAAG,QAAQ,MAAM,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,cAAc,CAAC;AAEzE;;;;;;;;;;;;GAYG;AACH,qBAAa,gBAAgB,CAAC,YAAY;IACtC,SAAS,CAAC,cAAc,EAAE,CAAC,IAAI,EAAE,cAAc,EAAE,QAAQ,EAAE,cAAc,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;;IAS7F,SAAS,CAAC,aAAa,EAAE;QACrB,SAAS,EAAE,iBAAiB,CAAC;QAC7B,UAAU,EAAE,MAAM,CAAC;QACnB,EAAE,EAAE,CAAC,IAAI,EAAE,cAAc,EAAE,QAAQ,EAAE,cAAc,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;KAC1E,EAAE,CAAM;IAET,SAAS,CAAC,YAAY,EAAE;QACpB,aAAa,EAAE,iBAAiB,CAAC;QACjC,SAAS,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,cAAc,CAAC;KACvD,EAAE,CAAM;IAET;;;;;OAKG;IACI,eAAe,CAClB,UAAU,SAAS,MAAM,EACzB,UAAU,SAAS,SAAS,EAC5B,QAAQ,SAAS,CAAC,IAAI,EAAE,YAAY,CAAC,UAAU,CAAC,EAAE,QAAQ,EAAE,cAAc,EAAE,KAAK,GAAG,EACtF,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,EAAE,EAAE,QAAQ,sCAmBxC,EAAE;;;IAoCvB;;;;;;;;;;;;OAYG;IACI,aAAa,CAAC,aAAa,SAAS,iBAAiB,EACxD,aAAa,EAAE,aAAa,EAC5B,SAAS,EAAE,CAAC,gBAAgB,EAAE,YAAY,CAAC,aAAa,CAAC,KAAK,cAAc;IAuChF;;;;OAIG;IACI,UAAU,CAAC,EAAE,EAAE,CAAC,IAAI,EAAE,cAAc,EAAE,QAAQ,EAAE,cAAc,EAAE,KAAK,GAAG;IAKxE,KAAK,IAAI,SAAS,CAAC,YAAY,CAAC;CA8B1C"}

package/dist/registrarBuilder.js

@@ -1,4 +1,4 @@
-export { RegistrarBuilder } from './RGGHMCTO.js';
+export { RegistrarBuilder } from './6D5TVHOU.js';
 import './VUOMXK5T.js';
 //# sourceMappingURL=registrarBuilder.js.map
 //# sourceMappingURL=registrarBuilder.js.map

package/dist/utils.cjs

@@ -1,14 +1,14 @@
 'use strict';
 
-var BJOVDE43_cjs = require('./BJOVDE43.cjs');
-require('./GD77KZDY.cjs');
+var ZSYU3OBT_cjs = require('./ZSYU3OBT.cjs');
+require('./U3E5EB56.cjs');
 require('./YJF4D23A.cjs');
 
 
 
 Object.defineProperty(exports, "extractSchemaFromFactory", {
   enumerable: true,
-  get: function () { return BJOVDE43_cjs.extractSchemaFromFactory; }
+  get: function () { return ZSYU3OBT_cjs.extractSchemaFromFactory; }
 });
 //# sourceMappingURL=utils.cjs.map
 //# sourceMappingURL=utils.cjs.map

package/dist/utils.js

@@ -1,5 +1,5 @@
-export { extractSchemaFromFactory } from './P5NNX2LK.js';
-import './3GFGHSFN.js';
+export { extractSchemaFromFactory } from './G24SMCHK.js';
+import './JV365MVS.js';
 import './VUOMXK5T.js';
 //# sourceMappingURL=utils.js.map
 //# sourceMappingURL=utils.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layerzerolabs/base-definitions",
-  "version": "0.0.44",
+  "version": "0.0.46",
   "private": false,
   "license": "MIT",
   "type": "module",
@@ -15,16 +15,16 @@
   "types": "./dist/index.d.ts",
   "dependencies": {
     "zod": "^3.23.8",
-    "@layerzerolabs/common-utils": "0.0.44",
-    "@layerzerolabs/dependency-graph": "0.0.44",
-    "@layerzerolabs/dfs": "0.0.44",
-    "@layerzerolabs/typescript-utils": "0.0.44"
+    "@layerzerolabs/common-utils": "0.0.46",
+    "@layerzerolabs/typescript-utils": "0.0.46",
+    "@layerzerolabs/dependency-graph": "0.0.46",
+    "@layerzerolabs/dfs": "0.0.46"
   },
   "devDependencies": {
     "tsup": "^8.4.0",
     "vitest": "^3.2.3",
-    "@layerzerolabs/tsup-configuration": "0.0.44",
-    "@layerzerolabs/typescript-configuration": "0.0.44"
+    "@layerzerolabs/tsup-configuration": "0.0.46",
+    "@layerzerolabs/typescript-configuration": "0.0.46"
   },
   "publishConfig": {
     "access": "restricted",

package/src/definitions.ts

@@ -19,7 +19,7 @@ export type DimensionToSchemaMap<DimConstraint extends object = object> = {
 
 export type FactorySpecialization<DMap extends DimensionToSchemaMap = DimensionToSchemaMap> = {
     spec: z.ZodObject<any>;
-    exempt: readonly (keyof GetSupersetOfModelsFromSchema<DMap>)[];
+    exempt: readonly MethodNameOf<GetSupersetOfModelsFromSchema<DMap>>[];
 };
 
 export type WithInjectedSpecialization<T, Specialization extends FactorySpecialization<any>> = [
@@ -213,10 +213,12 @@ export type ResolvedDefinition<Definition extends DependencyNode<any, any>> =
             : unknown;
 
 /**
- * Given a record from string to definition, maps each definition T to ResolvedDefinition<T>
+ * Given a record from string to definition, maps each definition T to ResolvedDefinition<T>. Removes `definition` suffix from name
  */
 export type ResolvedDefinitionMap<Deps extends Dependencies> = {
-    [Key in keyof Deps]: ResolvedDefinition<Deps[Key]>;
+    [Key in keyof Deps as Key extends `${infer Name}Definition` ? Name : Key]: ResolvedDefinition<
+        Deps[Key]
+    >;
 };
 
 /**
@@ -239,24 +241,43 @@ export type ResolvedFactoryImplementation<Definition extends DependencyNode<any,
  * Given a record from string to definition and some dimension D, maps each definition T to ResolvedFactoryImplementation<T, D>
  */
 export type ResolvedFactoryImplementationMap<Deps extends Dependencies, Dim> = RemoveNever<{
-    [Key in keyof Deps]: ResolvedFactoryImplementation<Deps[Key], Dim>;
+    [Key in keyof Deps as Key extends `${infer Name}Definition`
+        ? Name
+        : Key]: ResolvedFactoryImplementation<Deps[Key], Dim>;
 }>;
 
 type ActivityFactoryContext<
     _FactoryDefinition extends FactoryDefinition<any, any, any, any, any>,
     Dim,
+    _PrivateSchemaExtension extends z.ZodObject = z.ZodObject<{}, z.core.$strip>,
 > = {
     getFunctionPointer: <
-        MethodName extends MethodNameOf<ResolvedFactoryImplementation<_FactoryDefinition, Dim>>,
+        MethodName extends MethodNameOf<
+            ResolvedFactoryImplementation<_FactoryDefinition, Dim> &
+                WithInjectedSpecialization<
+                    z.infer<_PrivateSchemaExtension>,
+                    _FactoryDefinition['specialization']
+                >
+        >,
     >(
         methodName: MethodName,
-    ) => FunctionPointer<ResolvedFactoryImplementation<_FactoryDefinition, Dim>[MethodName]>;
+    ) => FunctionPointer<
+        (ResolvedFactoryImplementation<_FactoryDefinition, Dim> &
+            WithInjectedSpecialization<
+                z.infer<_PrivateSchemaExtension>,
+                _FactoryDefinition['specialization']
+            >)[MethodName]
+    >;
 };
 
 /**
  * The parameters that shall be received by a factory's implementation getter
  */
-export type Context<_FactoryDefinition extends FactoryDefinition<any, any, any, any, any>, Dim> = {
+export type Context<
+    _FactoryDefinition extends FactoryDefinition<any, any, any, any, any>,
+    Dim,
+    _PrivateSchemaExtension extends z.ZodObject = z.ZodObject<{}, z.core.$strip>,
+> = {
     name: _FactoryDefinition extends FactoryDefinition<infer Name, any, any, any, any>
         ? Name
         : never;
@@ -267,8 +288,8 @@ export type Context<_FactoryDefinition extends FactoryDefinition<any, any, any,
     impls: _FactoryDefinition extends FactoryDefinition<any, any, any, any, infer Deps>
         ? ResolvedFactoryImplementationMap<Deps, Dim>
         : never;
-    self: ResolvedFactoryImplementation<_FactoryDefinition, Dim>;
-} & ActivityFactoryContext<_FactoryDefinition, Dim>;
+    self: ResolvedFactoryImplementation<_FactoryDefinition, Dim> & z.infer<_PrivateSchemaExtension>;
+} & ActivityFactoryContext<_FactoryDefinition, Dim, _PrivateSchemaExtension>;
 
 export const serializeDimensions = (dim: object = {}) => {
     return Object.keys(dim).length

package/src/registrarBuilder.ts

@@ -1,7 +1,7 @@
 import type { DependencyNode } from '@layerzerolabs/dependency-graph';
 import type { Registrar } from '@layerzerolabs/dfs';
-export type { Registrar };
 import { dfs } from '@layerzerolabs/dfs';
+export type { Registrar };
 
 type NodeClass = new (...args: any[]) => DependencyNode;
 type AbstractNodeClass = abstract new (...args: any[]) => DependencyNode;
@@ -69,7 +69,7 @@ export class RegistrarBuilder<_ReturnTypes> {
 
                 return this as RegistrarBuilder<
                     _ReturnTypes & {
-                        [K in Identifier]: { [nodeName: string]: Awaited<ReturnType<Function>> };
+                        [_K in Identifier]: { [nodeName: string]: Awaited<ReturnType<Function>> };
                     }
                 >;
             }
@@ -85,7 +85,7 @@ export class RegistrarBuilder<_ReturnTypes> {
 
                 return this as RegistrarBuilder<
                     _ReturnTypes & {
-                        [K in Identifier]: { [nodeName: string]: Awaited<ReturnType<Function>> };
+                        [_K in Identifier]: { [nodeName: string]: Awaited<ReturnType<Function>> };
                     }
                 >;
             }
@@ -100,7 +100,7 @@ export class RegistrarBuilder<_ReturnTypes> {
 
         return this as RegistrarBuilder<
             _ReturnTypes & {
-                [K in Identifier]: { [nodeName: string]: Awaited<ReturnType<Function>> };
+                [_K in Identifier]: { [nodeName: string]: Awaited<ReturnType<Function>> };
             }
         >;
     }

package/dist/3GFGHSFN.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/definitions.ts"],"names":["FactoryDefinition","DependencyNode","dimensions","specialization","dimensionToSchemaMap","getFactory","args","ObjectDefinition","schema","serializeDimensions","dim","Object","keys","length","entries","sort","map","dimName","dimVal","join"],"mappings":";;;AA+HO,IAAMA,iBAAAA,GAAN,cAMGC,cAAAA,CAAAA;EAjIV;;;AAkIoBC,EAAAA,UAAAA;AACAC,EAAAA,cAAAA;AACAC,EAAAA,oBAAAA;AACAC,EAAAA,UAAAA;AAChB,EAAA,WAAA,CAAY,EACRH,UAAAA,EACAC,cAAAA,EACAC,sBACAC,UAAAA,EACA,GAAGC,MAAAA,EAMmE;AACtE,IAAA,KAAA,CAAMA,IAAAA,CAAAA;AACN,IAAA,IAAA,CAAKJ,UAAAA,GAAaA,UAAAA;AAClB,IAAA,IAAA,CAAKC,cAAAA,GAAiBA,cAAAA;AACtB,IAAA,IAAA,CAAKC,oBAAAA,GAAuBA,oBAAAA;AAC5B,IAAA,IAAA,CAAKC,UAAAA,GAAaA,UAAAA;AACtB,EAAA;AACJ;AAaO,IAAeE,gBAAAA,GAAf,cAIGN,cAAAA,CAAAA;EAzKV;;;AA0KoBO,EAAAA,MAAAA;AAEhB,EAAA,WAAA,CAAY,EACRA,MAAAA,EACA,GAAGF,IAAAA,EAAAA,EAGmE;AACtE,IAAA,KAAA,CAAMA,IAAAA,CAAAA;AACN,IAAA,IAAA,CAAKE,MAAAA,GAASA,MAAAA;AAClB,EAAA;AACJ;AAuFO,IAAMC,mBAAAA,mBAAsB,MAAA,CAAA,CAACC,GAAAA,GAAc,EAAC,KAAC;AAChD,EAAA,OAAOC,MAAAA,CAAOC,IAAAA,CAAKF,GAAAA,CAAAA,CAAKG,MAAAA,GAClBF,MAAAA,CAAOG,OAAAA,CAAQJ,GAAAA,CAAAA,CACVK,IAAAA,EAAI,CACJC,GAAAA,CAAI,CAAC,CAACC,OAAAA,EAASC,MAAAA,CAAAA,KAAY,CAAA,EAAGD,OAAAA,CAAAA,CAAAA,EAAWC,MAAAA,CAAAA,CAAAA,EAAU,EAAA,CAAA,CACnDC,IAAAA,CAAK,GAAA,CAAA,GACV,OAAA;AACV,CAAA,EAPmC,qBAAA","file":"3GFGHSFN.js","sourcesContent":["import type { z } from 'zod/v4';\n\nimport type { FunctionPointer } from '@layerzerolabs/common-utils';\nimport type { Dependencies } from '@layerzerolabs/dependency-graph';\nimport { DependencyNode } from '@layerzerolabs/dependency-graph';\nimport type {\n    AdvancedRecord,\n    AdvancedRecordLookup,\n    Merge,\n    MethodNameOf,\n    RemoveNever,\n    UnionToIntersection,\n} from '@layerzerolabs/typescript-utils';\n\nexport type DimensionToSchemaMap<DimConstraint extends object = object> = {\n    byDimension?: AdvancedRecord<DimConstraint, z.ZodType>;\n    base: z.ZodType;\n};\n\nexport type FactorySpecialization<DMap extends DimensionToSchemaMap = DimensionToSchemaMap> = {\n    spec: z.ZodObject<any>;\n    exempt: readonly (keyof GetSupersetOfModelsFromSchema<DMap>)[];\n};\n\nexport type WithInjectedSpecialization<T, Specialization extends FactorySpecialization<any>> = [\n    {},\n] extends [z.infer<Specialization['spec']>]\n    ? T\n    : {\n          [K in keyof T]: K extends Specialization['exempt'][number]\n              ? T[K]\n              : T[K] extends (...args: infer A) => infer R\n                ? (specialization: z.infer<Specialization['spec']>, ...args: A) => R\n                : T[K];\n      };\n\nexport type WithSpecializeMethod<WithInjection, WithoutInjection, S> = {} extends S\n    ? WithoutInjection\n    : WithInjection extends (...args: infer Args) => infer Ret\n      ? (...args: Args) => Ret\n      : WithInjection & {\n            specialize: (specialization: S) => WithoutInjection;\n        };\n\nexport type GetModelFromSchema<DMap extends DimensionToSchemaMap, Dim> =\n    AdvancedRecordLookup<DMap['byDimension'], Dim> extends never\n        ? z.infer<DMap['base']>\n        : Merge<z.infer<DMap['base']>, z.infer<AdvancedRecordLookup<DMap['byDimension'], Dim>>>;\n\nexport type GetSupersetOfModelsFromSchema<DMap extends DimensionToSchemaMap> = UnionToIntersection<\n    {\n        [Key in keyof DMap['byDimension']]: DMap['byDimension'][Key] extends [any, any]\n            ? z.infer<DMap['byDimension'][Key][1]>\n            : never;\n    }[keyof DMap['byDimension']]\n> &\n    z.infer<DMap['base']>;\n\ntype GetImplFunctionWithConditionalOptionalDim<Dim, Return> = {} extends Dim\n    ? (dim?: Dim) => Return\n    : (dim: Dim) => Return;\n\ntype GetImplOverloads<\n    Dim extends z.ZodObject<any>,\n    Specialization extends FactorySpecialization<DMap>,\n    DMap extends DimensionToSchemaMap<z.infer<Dim>>,\n> = UnionToIntersection<\n    | {\n          [I in keyof DMap['byDimension']]: DMap['byDimension'][I] extends readonly [infer K, any]\n              ? {\n                    getImpl: GetImplFunctionWithConditionalOptionalDim<\n                        K,\n                        WithSpecializeMethod<\n                            WithInjectedSpecialization<GetModelFromSchema<DMap, K>, Specialization>,\n                            GetModelFromSchema<DMap, K>,\n                            z.infer<Specialization['spec']>\n                        >\n                    >;\n                }\n              : never;\n      }[keyof DMap['byDimension']]\n    | {\n          getImpl: GetImplFunctionWithConditionalOptionalDim<\n              z.infer<Dim>,\n              WithSpecializeMethod<\n                  WithInjectedSpecialization<z.infer<DMap['base']>, Specialization>,\n                  z.infer<DMap['base']>,\n                  z.infer<Specialization['spec']>\n              >\n          >;\n      }\n>;\n\nexport type Factory<\n    _Dependencies extends Dependencies,\n    Dim extends z.ZodObject<any>,\n    Specialization extends FactorySpecialization<DMap>,\n    DMap extends DimensionToSchemaMap<z.infer<Dim>>,\n> = {\n    name: string;\n    implKeys: string[];\n    dimensionToSchemaMap: DMap;\n} & GetImplOverloads<Dim, Specialization, DMap>;\n\nexport type GetFactory<\n    _Dependencies extends Dependencies,\n    Dim extends z.ZodObject<any>,\n    Specialization extends FactorySpecialization<DMap>,\n    DMap extends DimensionToSchemaMap<z.infer<Dim>>,\n> = () =>\n    | Factory<_Dependencies, Dim, Specialization, DMap>\n    | Promise<Factory<_Dependencies, Dim, Specialization, DMap>>;\n\n/**\n * <!-- anchor:FactoryDefinition -->\n * Factory definitions are a type of dependency node that shall be resolved to a *factory*.\n * A factory is an object that provides a getImpl method which accepts some parameters `dim`,\n * and returns some object `getImplMetadata.getModel(dim)`.\n * That is, a factory definition is given by the set of parameters it uses to get its implementations,\n * and a function defining the schema it will return for each set of parameters.\n * @param name inherited from {@link DependencyNode}\n * @param dependencies inherited from {@link DependencyNode}\n * @param dimensions a Zod schema for the parameters this factory operates on.\n * @param dimensionToSchemaMap A map from dimension objects to the Zod schema for the implementation.\n * @param getFactory a method that should return an object with a `getImpl` method that returns\n * entities adhering to the schema for the corresponding `getModel` call\n */\nexport class FactoryDefinition<\n    Name extends string,\n    Dim extends z.ZodObject<any>,\n    const Specialization extends FactorySpecialization<DMap>,\n    DMap extends DimensionToSchemaMap<z.infer<Dim>>,\n    _Dependencies extends Dependencies,\n> extends DependencyNode<Name, _Dependencies> {\n    public readonly dimensions: Dim;\n    public readonly specialization: Specialization;\n    public readonly dimensionToSchemaMap: DMap;\n    public readonly getFactory: GetFactory<_Dependencies, Dim, Specialization, DMap>;\n    constructor({\n        dimensions,\n        specialization,\n        dimensionToSchemaMap,\n        getFactory,\n        ...args\n    }: {\n        dimensions: Dim;\n        specialization: Specialization;\n        dimensionToSchemaMap: DMap;\n        getFactory: GetFactory<_Dependencies, Dim, Specialization, DMap>;\n    } & ConstructorParameters<typeof DependencyNode<Name, _Dependencies>>[0]) {\n        super(args);\n        this.dimensions = dimensions;\n        this.specialization = specialization;\n        this.dimensionToSchemaMap = dimensionToSchemaMap;\n        this.getFactory = getFactory;\n    }\n}\n\n/**\n * <!-- anchor:ObjectDefinition -->\n * An object definition is a dependency node that refers to some entity\n * matching a given schema. That is, it may be resolved to any entity\n * that adheres to the {@link schema}.\n * The object definition is abstract, as it cannot be meaningfully resolved without\n * additional information. For an example of an object definition, see ReflexiveObjectDefinition or ContextDefinition\n * @param name inherited from {@link DependencyNode}\n * @param dependencies inherited from {@link DependencyNode}\n * @param schema a Zod schema defining the expected resolution for this definition\n */\nexport abstract class ObjectDefinition<\n    Name extends string,\n    Schema extends z.ZodSchema,\n    _Dependencies extends Dependencies,\n> extends DependencyNode<Name, _Dependencies> {\n    public readonly schema: Schema;\n\n    constructor({\n        schema,\n        ...args\n    }: {\n        schema: Schema;\n    } & ConstructorParameters<typeof DependencyNode<Name, _Dependencies>>[0]) {\n        super(args);\n        this.schema = schema;\n    }\n}\n\nexport type Definition<Name extends string> =\n    | FactoryDefinition<Name, any, any, any, any>\n    | ObjectDefinition<Name, any, any>;\n\n/**\n * Infers the expected type of a definition once it has been resolved\n */\nexport type ResolvedDefinition<Definition extends DependencyNode<any, any>> =\n    Definition extends ObjectDefinition<any, infer Schema, any>\n        ? z.infer<Schema>\n        : Definition extends FactoryDefinition<\n                any,\n                infer Dim,\n                infer Specialization,\n                infer DMap,\n                any\n            >\n          ? Factory<Definition['dependencies'], Dim, Specialization, DMap>\n          : Definition extends FactoryDefinition<any, any, any, any, any>\n            ? Factory<\n                  Definition['dependencies'],\n                  Definition['dimensions'],\n                  Definition['specialization'],\n                  Definition['dimensionToSchemaMap']\n              >\n            : unknown;\n\n/**\n * Given a record from string to definition, maps each definition T to ResolvedDefinition<T>\n */\nexport type ResolvedDefinitionMap<Deps extends Dependencies> = {\n    [Key in keyof Deps]: ResolvedDefinition<Deps[Key]>;\n};\n\n/**\n * For some factory definition F and some dimension D s.t. D ⊇ F.dimensions, infers the expected return type of\n * ResolvedDefinition<F>.getImpl(D)\n */\nexport type ResolvedFactoryImplementation<Definition extends DependencyNode<any, any>, Dim> =\n    Definition extends FactoryDefinition<any, any, any, any, any>\n        ? WithSpecializeMethod<\n              WithInjectedSpecialization<\n                  GetModelFromSchema<Definition['dimensionToSchemaMap'], Dim>,\n                  Definition['specialization']\n              >,\n              GetModelFromSchema<Definition['dimensionToSchemaMap'], Dim>,\n              z.infer<Definition['specialization']['spec']>\n          >\n        : never;\n\n/**\n * Given a record from string to definition and some dimension D, maps each definition T to ResolvedFactoryImplementation<T, D>\n */\nexport type ResolvedFactoryImplementationMap<Deps extends Dependencies, Dim> = RemoveNever<{\n    [Key in keyof Deps]: ResolvedFactoryImplementation<Deps[Key], Dim>;\n}>;\n\ntype ActivityFactoryContext<\n    _FactoryDefinition extends FactoryDefinition<any, any, any, any, any>,\n    Dim,\n> = {\n    getFunctionPointer: <\n        MethodName extends MethodNameOf<ResolvedFactoryImplementation<_FactoryDefinition, Dim>>,\n    >(\n        methodName: MethodName,\n    ) => FunctionPointer<ResolvedFactoryImplementation<_FactoryDefinition, Dim>[MethodName]>;\n};\n\n/**\n * The parameters that shall be received by a factory's implementation getter\n */\nexport type Context<_FactoryDefinition extends FactoryDefinition<any, any, any, any, any>, Dim> = {\n    name: _FactoryDefinition extends FactoryDefinition<infer Name, any, any, any, any>\n        ? Name\n        : never;\n    dependencies: _FactoryDefinition extends FactoryDefinition<any, any, any, any, infer Deps>\n        ? ResolvedDefinitionMap<Deps>\n        : never;\n    dim: Dim;\n    impls: _FactoryDefinition extends FactoryDefinition<any, any, any, any, infer Deps>\n        ? ResolvedFactoryImplementationMap<Deps, Dim>\n        : never;\n    self: ResolvedFactoryImplementation<_FactoryDefinition, Dim>;\n} & ActivityFactoryContext<_FactoryDefinition, Dim>;\n\nexport const serializeDimensions = (dim: object = {}) => {\n    return Object.keys(dim).length\n        ? Object.entries(dim)\n              .sort()\n              .map(([dimName, dimVal]) => `${dimName}_${dimVal}`, '')\n              .join('&')\n        : '_base';\n};\n"]}

package/dist/GD77KZDY.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/definitions.ts"],"names":["FactoryDefinition","DependencyNode","dimensions","specialization","dimensionToSchemaMap","getFactory","args","ObjectDefinition","schema","serializeDimensions","__name","dim","Object","keys","length","entries","sort","map","dimName","dimVal","join"],"mappings":";;;;;AA+HO,IAAMA,iBAAAA,GAAN,cAMGC,8BAAAA,CAAAA;EAjIV;;;AAkIoBC,EAAAA,UAAAA;AACAC,EAAAA,cAAAA;AACAC,EAAAA,oBAAAA;AACAC,EAAAA,UAAAA;AAChB,EAAA,WAAA,CAAY,EACRH,UAAAA,EACAC,cAAAA,EACAC,sBACAC,UAAAA,EACA,GAAGC,MAAAA,EAMmE;AACtE,IAAA,KAAA,CAAMA,IAAAA,CAAAA;AACN,IAAA,IAAA,CAAKJ,UAAAA,GAAaA,UAAAA;AAClB,IAAA,IAAA,CAAKC,cAAAA,GAAiBA,cAAAA;AACtB,IAAA,IAAA,CAAKC,oBAAAA,GAAuBA,oBAAAA;AAC5B,IAAA,IAAA,CAAKC,UAAAA,GAAaA,UAAAA;AACtB,EAAA;AACJ;AAaO,IAAeE,gBAAAA,GAAf,cAIGN,8BAAAA,CAAAA;EAzKV;;;AA0KoBO,EAAAA,MAAAA;AAEhB,EAAA,WAAA,CAAY,EACRA,MAAAA,EACA,GAAGF,IAAAA,EAAAA,EAGmE;AACtE,IAAA,KAAA,CAAMA,IAAAA,CAAAA;AACN,IAAA,IAAA,CAAKE,MAAAA,GAASA,MAAAA;AAClB,EAAA;AACJ;AAuFO,IAAMC,mBAAAA,mBAAsBC,mBAAA,CAAA,CAACC,GAAAA,GAAc,EAAC,KAAC;AAChD,EAAA,OAAOC,MAAAA,CAAOC,IAAAA,CAAKF,GAAAA,CAAAA,CAAKG,MAAAA,GAClBF,MAAAA,CAAOG,OAAAA,CAAQJ,GAAAA,CAAAA,CACVK,IAAAA,EAAI,CACJC,GAAAA,CAAI,CAAC,CAACC,OAAAA,EAASC,MAAAA,CAAAA,KAAY,CAAA,EAAGD,OAAAA,CAAAA,CAAAA,EAAWC,MAAAA,CAAAA,CAAAA,EAAU,EAAA,CAAA,CACnDC,IAAAA,CAAK,GAAA,CAAA,GACV,OAAA;AACV,CAAA,EAPmC,qBAAA","file":"GD77KZDY.cjs","sourcesContent":["import type { z } from 'zod/v4';\n\nimport type { FunctionPointer } from '@layerzerolabs/common-utils';\nimport type { Dependencies } from '@layerzerolabs/dependency-graph';\nimport { DependencyNode } from '@layerzerolabs/dependency-graph';\nimport type {\n    AdvancedRecord,\n    AdvancedRecordLookup,\n    Merge,\n    MethodNameOf,\n    RemoveNever,\n    UnionToIntersection,\n} from '@layerzerolabs/typescript-utils';\n\nexport type DimensionToSchemaMap<DimConstraint extends object = object> = {\n    byDimension?: AdvancedRecord<DimConstraint, z.ZodType>;\n    base: z.ZodType;\n};\n\nexport type FactorySpecialization<DMap extends DimensionToSchemaMap = DimensionToSchemaMap> = {\n    spec: z.ZodObject<any>;\n    exempt: readonly (keyof GetSupersetOfModelsFromSchema<DMap>)[];\n};\n\nexport type WithInjectedSpecialization<T, Specialization extends FactorySpecialization<any>> = [\n    {},\n] extends [z.infer<Specialization['spec']>]\n    ? T\n    : {\n          [K in keyof T]: K extends Specialization['exempt'][number]\n              ? T[K]\n              : T[K] extends (...args: infer A) => infer R\n                ? (specialization: z.infer<Specialization['spec']>, ...args: A) => R\n                : T[K];\n      };\n\nexport type WithSpecializeMethod<WithInjection, WithoutInjection, S> = {} extends S\n    ? WithoutInjection\n    : WithInjection extends (...args: infer Args) => infer Ret\n      ? (...args: Args) => Ret\n      : WithInjection & {\n            specialize: (specialization: S) => WithoutInjection;\n        };\n\nexport type GetModelFromSchema<DMap extends DimensionToSchemaMap, Dim> =\n    AdvancedRecordLookup<DMap['byDimension'], Dim> extends never\n        ? z.infer<DMap['base']>\n        : Merge<z.infer<DMap['base']>, z.infer<AdvancedRecordLookup<DMap['byDimension'], Dim>>>;\n\nexport type GetSupersetOfModelsFromSchema<DMap extends DimensionToSchemaMap> = UnionToIntersection<\n    {\n        [Key in keyof DMap['byDimension']]: DMap['byDimension'][Key] extends [any, any]\n            ? z.infer<DMap['byDimension'][Key][1]>\n            : never;\n    }[keyof DMap['byDimension']]\n> &\n    z.infer<DMap['base']>;\n\ntype GetImplFunctionWithConditionalOptionalDim<Dim, Return> = {} extends Dim\n    ? (dim?: Dim) => Return\n    : (dim: Dim) => Return;\n\ntype GetImplOverloads<\n    Dim extends z.ZodObject<any>,\n    Specialization extends FactorySpecialization<DMap>,\n    DMap extends DimensionToSchemaMap<z.infer<Dim>>,\n> = UnionToIntersection<\n    | {\n          [I in keyof DMap['byDimension']]: DMap['byDimension'][I] extends readonly [infer K, any]\n              ? {\n                    getImpl: GetImplFunctionWithConditionalOptionalDim<\n                        K,\n                        WithSpecializeMethod<\n                            WithInjectedSpecialization<GetModelFromSchema<DMap, K>, Specialization>,\n                            GetModelFromSchema<DMap, K>,\n                            z.infer<Specialization['spec']>\n                        >\n                    >;\n                }\n              : never;\n      }[keyof DMap['byDimension']]\n    | {\n          getImpl: GetImplFunctionWithConditionalOptionalDim<\n              z.infer<Dim>,\n              WithSpecializeMethod<\n                  WithInjectedSpecialization<z.infer<DMap['base']>, Specialization>,\n                  z.infer<DMap['base']>,\n                  z.infer<Specialization['spec']>\n              >\n          >;\n      }\n>;\n\nexport type Factory<\n    _Dependencies extends Dependencies,\n    Dim extends z.ZodObject<any>,\n    Specialization extends FactorySpecialization<DMap>,\n    DMap extends DimensionToSchemaMap<z.infer<Dim>>,\n> = {\n    name: string;\n    implKeys: string[];\n    dimensionToSchemaMap: DMap;\n} & GetImplOverloads<Dim, Specialization, DMap>;\n\nexport type GetFactory<\n    _Dependencies extends Dependencies,\n    Dim extends z.ZodObject<any>,\n    Specialization extends FactorySpecialization<DMap>,\n    DMap extends DimensionToSchemaMap<z.infer<Dim>>,\n> = () =>\n    | Factory<_Dependencies, Dim, Specialization, DMap>\n    | Promise<Factory<_Dependencies, Dim, Specialization, DMap>>;\n\n/**\n * <!-- anchor:FactoryDefinition -->\n * Factory definitions are a type of dependency node that shall be resolved to a *factory*.\n * A factory is an object that provides a getImpl method which accepts some parameters `dim`,\n * and returns some object `getImplMetadata.getModel(dim)`.\n * That is, a factory definition is given by the set of parameters it uses to get its implementations,\n * and a function defining the schema it will return for each set of parameters.\n * @param name inherited from {@link DependencyNode}\n * @param dependencies inherited from {@link DependencyNode}\n * @param dimensions a Zod schema for the parameters this factory operates on.\n * @param dimensionToSchemaMap A map from dimension objects to the Zod schema for the implementation.\n * @param getFactory a method that should return an object with a `getImpl` method that returns\n * entities adhering to the schema for the corresponding `getModel` call\n */\nexport class FactoryDefinition<\n    Name extends string,\n    Dim extends z.ZodObject<any>,\n    const Specialization extends FactorySpecialization<DMap>,\n    DMap extends DimensionToSchemaMap<z.infer<Dim>>,\n    _Dependencies extends Dependencies,\n> extends DependencyNode<Name, _Dependencies> {\n    public readonly dimensions: Dim;\n    public readonly specialization: Specialization;\n    public readonly dimensionToSchemaMap: DMap;\n    public readonly getFactory: GetFactory<_Dependencies, Dim, Specialization, DMap>;\n    constructor({\n        dimensions,\n        specialization,\n        dimensionToSchemaMap,\n        getFactory,\n        ...args\n    }: {\n        dimensions: Dim;\n        specialization: Specialization;\n        dimensionToSchemaMap: DMap;\n        getFactory: GetFactory<_Dependencies, Dim, Specialization, DMap>;\n    } & ConstructorParameters<typeof DependencyNode<Name, _Dependencies>>[0]) {\n        super(args);\n        this.dimensions = dimensions;\n        this.specialization = specialization;\n        this.dimensionToSchemaMap = dimensionToSchemaMap;\n        this.getFactory = getFactory;\n    }\n}\n\n/**\n * <!-- anchor:ObjectDefinition -->\n * An object definition is a dependency node that refers to some entity\n * matching a given schema. That is, it may be resolved to any entity\n * that adheres to the {@link schema}.\n * The object definition is abstract, as it cannot be meaningfully resolved without\n * additional information. For an example of an object definition, see ReflexiveObjectDefinition or ContextDefinition\n * @param name inherited from {@link DependencyNode}\n * @param dependencies inherited from {@link DependencyNode}\n * @param schema a Zod schema defining the expected resolution for this definition\n */\nexport abstract class ObjectDefinition<\n    Name extends string,\n    Schema extends z.ZodSchema,\n    _Dependencies extends Dependencies,\n> extends DependencyNode<Name, _Dependencies> {\n    public readonly schema: Schema;\n\n    constructor({\n        schema,\n        ...args\n    }: {\n        schema: Schema;\n    } & ConstructorParameters<typeof DependencyNode<Name, _Dependencies>>[0]) {\n        super(args);\n        this.schema = schema;\n    }\n}\n\nexport type Definition<Name extends string> =\n    | FactoryDefinition<Name, any, any, any, any>\n    | ObjectDefinition<Name, any, any>;\n\n/**\n * Infers the expected type of a definition once it has been resolved\n */\nexport type ResolvedDefinition<Definition extends DependencyNode<any, any>> =\n    Definition extends ObjectDefinition<any, infer Schema, any>\n        ? z.infer<Schema>\n        : Definition extends FactoryDefinition<\n                any,\n                infer Dim,\n                infer Specialization,\n                infer DMap,\n                any\n            >\n          ? Factory<Definition['dependencies'], Dim, Specialization, DMap>\n          : Definition extends FactoryDefinition<any, any, any, any, any>\n            ? Factory<\n                  Definition['dependencies'],\n                  Definition['dimensions'],\n                  Definition['specialization'],\n                  Definition['dimensionToSchemaMap']\n              >\n            : unknown;\n\n/**\n * Given a record from string to definition, maps each definition T to ResolvedDefinition<T>\n */\nexport type ResolvedDefinitionMap<Deps extends Dependencies> = {\n    [Key in keyof Deps]: ResolvedDefinition<Deps[Key]>;\n};\n\n/**\n * For some factory definition F and some dimension D s.t. D ⊇ F.dimensions, infers the expected return type of\n * ResolvedDefinition<F>.getImpl(D)\n */\nexport type ResolvedFactoryImplementation<Definition extends DependencyNode<any, any>, Dim> =\n    Definition extends FactoryDefinition<any, any, any, any, any>\n        ? WithSpecializeMethod<\n              WithInjectedSpecialization<\n                  GetModelFromSchema<Definition['dimensionToSchemaMap'], Dim>,\n                  Definition['specialization']\n              >,\n              GetModelFromSchema<Definition['dimensionToSchemaMap'], Dim>,\n              z.infer<Definition['specialization']['spec']>\n          >\n        : never;\n\n/**\n * Given a record from string to definition and some dimension D, maps each definition T to ResolvedFactoryImplementation<T, D>\n */\nexport type ResolvedFactoryImplementationMap<Deps extends Dependencies, Dim> = RemoveNever<{\n    [Key in keyof Deps]: ResolvedFactoryImplementation<Deps[Key], Dim>;\n}>;\n\ntype ActivityFactoryContext<\n    _FactoryDefinition extends FactoryDefinition<any, any, any, any, any>,\n    Dim,\n> = {\n    getFunctionPointer: <\n        MethodName extends MethodNameOf<ResolvedFactoryImplementation<_FactoryDefinition, Dim>>,\n    >(\n        methodName: MethodName,\n    ) => FunctionPointer<ResolvedFactoryImplementation<_FactoryDefinition, Dim>[MethodName]>;\n};\n\n/**\n * The parameters that shall be received by a factory's implementation getter\n */\nexport type Context<_FactoryDefinition extends FactoryDefinition<any, any, any, any, any>, Dim> = {\n    name: _FactoryDefinition extends FactoryDefinition<infer Name, any, any, any, any>\n        ? Name\n        : never;\n    dependencies: _FactoryDefinition extends FactoryDefinition<any, any, any, any, infer Deps>\n        ? ResolvedDefinitionMap<Deps>\n        : never;\n    dim: Dim;\n    impls: _FactoryDefinition extends FactoryDefinition<any, any, any, any, infer Deps>\n        ? ResolvedFactoryImplementationMap<Deps, Dim>\n        : never;\n    self: ResolvedFactoryImplementation<_FactoryDefinition, Dim>;\n} & ActivityFactoryContext<_FactoryDefinition, Dim>;\n\nexport const serializeDimensions = (dim: object = {}) => {\n    return Object.keys(dim).length\n        ? Object.entries(dim)\n              .sort()\n              .map(([dimName, dimVal]) => `${dimName}_${dimVal}`, '')\n              .join('&')\n        : '_base';\n};\n"]}