libmodulor 0.18.0 → 0.19.0

package/dist/esm/target/node-core-cli/NodeCoreCLIManager.js

@@ -21,14 +21,17 @@ import { print } from '../lib/cli/renderer.js';
 import { showHelp } from './commands.js';
 let NodeCoreCLIManager = class NodeCoreCLIManager {
     commandExecutor;
+    i18nManager;
     productUCsLoader;
     wordingManager;
-    constructor(commandExecutor, productUCsLoader, wordingManager) {
+    constructor(commandExecutor, i18nManager, productUCsLoader, wordingManager) {
         this.commandExecutor = commandExecutor;
+        this.i18nManager = i18nManager;
         this.productUCsLoader = productUCsLoader;
         this.wordingManager = wordingManager;
     }
     async handleCommand({ appsRootPath, srcImporter, }) {
+        await this.i18nManager.init();
         const command = process.argv[2] ?? '';
         const ucs = await this.productUCsLoader.exec({
             appsRootPath,
@@ -84,10 +87,10 @@ let NodeCoreCLIManager = class NodeCoreCLIManager {
 NodeCoreCLIManager = __decorate([
     injectable(),
     __param(0, inject(CommandExecutor)),
-    __param(1, inject(ProductUCsLoader)),
-    __param(2, inject(WordingManager)),
-    __metadata("design:paramtypes", [CommandExecutor,
-        ProductUCsLoader,
+    __param(1, inject('I18nManager')),
+    __param(2, inject(ProductUCsLoader)),
+    __param(3, inject(WordingManager)),
+    __metadata("design:paramtypes", [CommandExecutor, Object, ProductUCsLoader,
         WordingManager])
 ], NodeCoreCLIManager);
 export { NodeCoreCLIManager };

package/dist/esm/target/node-express-server/NodeExpressServerManager.d.ts

@@ -7,8 +7,9 @@ import { EntrypointsBuilder } from '../lib/server/EntrypointsBuilder.js';
 import type { ServerManager, ServerManagerSettings } from '../lib/server/ServerManager.js';
 import { ServerRequestHandler } from '../lib/server/ServerRequestHandler.js';
 import { ServerSSLCertLoader } from '../lib/server/ServerSSLCertLoader.js';
-import { HelmetMiddlewareBuilder } from './middlewares/HelmetMiddlewareBuilder.js';
-type S = Pick<LoggerSettings, 'logger_level'> & Pick<ServerManagerSettings, 'server_binding_host' | 'server_binding_port' | 'server_tmp_path'>;
+import { HelmetMiddlewareBuilder } from '../lib/server-express/HelmetMiddlewareBuilder.js';
+import type { ListenSettings } from '../lib/server-node/types.js';
+type S = ListenSettings & Pick<LoggerSettings, 'logger_level'> & Pick<ServerManagerSettings, 'server_tmp_path'>;
 export declare class NodeExpressServerManager implements Configurable<S>, ServerManager {
     private entrypointsBuilder;
     protected environmentManager: EnvironmentManager;
@@ -25,14 +26,14 @@ export declare class NodeExpressServerManager implements Configurable<S>, Server
     getRuntime(): Express;
     overrideUCManager(ucManager: UCManager): void;
     init(): Promise<void>;
+    initSync(): void;
     mount<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(appManifest: AppManifest, ucd: UCDef<I, OPI0, OPI1>, contract: UCHTTPContract): Promise<void>;
+    mountSync<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(appManifest: AppManifest, ucd: UCDef<I, OPI0, OPI1>, contract: UCHTTPContract): void;
     mountStaticDir(dirPath: DirPath): Promise<void>;
     start(): Promise<void>;
     stop(): Promise<void>;
     warmUp(): Promise<void>;
     private createServer;
-    private toFile;
-    private toReq;
-    private toRes;
+    private mountCommon;
 }
 export {};

package/dist/esm/target/node-express-server/NodeExpressServerManager.js

@@ -12,15 +12,15 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import http from 'node:http';
 import https from 'node:https';
-import cookieParser from 'cookie-parser';
 import express, {} from 'express';
-import fileUpload from 'express-fileupload';
 import { inject, injectable } from 'inversify';
+import { NotCallableError } from '../../error/index.js';
 import { EntrypointsBuilder } from '../lib/server/EntrypointsBuilder.js';
-import { ServerRequestHandler, } from '../lib/server/ServerRequestHandler.js';
+import { ServerRequestHandler } from '../lib/server/ServerRequestHandler.js';
 import { ServerSSLCertLoader } from '../lib/server/ServerSSLCertLoader.js';
-import { stop } from '../lib/server-node/stop.js';
-import { HelmetMiddlewareBuilder } from './middlewares/HelmetMiddlewareBuilder.js';
+import { buildHandler, init, mountHandler, } from '../lib/server-express/funcs.js';
+import { HelmetMiddlewareBuilder } from '../lib/server-express/HelmetMiddlewareBuilder.js';
+import { listen, stop } from '../lib/server-node/funcs.js';
 let NodeExpressServerManager = class NodeExpressServerManager {
     entrypointsBuilder;
     environmentManager;
@@ -60,53 +60,23 @@ let NodeExpressServerManager = class NodeExpressServerManager {
         this.ucManager = ucManager;
     }
     async init() {
-        this.runtime = express();
-        this.runtime.use(this.helmetMB.exec({}));
-        // TODO : Add FileStorageManager (Local, S3, FSBucket)
-        // Right now, the files are only stored locally. We need more flexibility. Maybe we can also install https://imgproxy.net.
-        this.runtime.use(fileUpload({
-            createParentPath: true,
-            debug: this.s().logger_level === 'trace',
-            tempFileDir: this.s().server_tmp_path,
-            useTempFiles: true,
-        }));
-        this.runtime.use(express.json());
-        this.runtime.use(express.urlencoded({ extended: true }));
-        this.runtime.use(cookieParser());
+        this.runtime = init(this.helmetMB, this.s().logger_level, this.s().server_tmp_path);
         await this.createServer();
     }
+    initSync() {
+        throw new NotCallableError('initSync', 'init', 'async-only');
+    }
     async mount(appManifest, ucd, contract) {
-        const { envelope, method, path, pathAliases } = contract;
-        const httpMethod = method.toLowerCase();
-        const handler = async (req, res) => {
-            const { body, status } = await this.serverRequestHandler.exec({
-                appManifest,
-                envelope,
-                req: this.toReq(req),
-                res: this.toRes(res),
-                ucd,
-                ucManager: this.ucManager,
-            });
-            if (!body) {
-                res.status(status).send();
-                return;
-            }
-            res.status(status).send(body);
-        };
-        this.runtime[httpMethod](path, handler);
-        for (const pathAlias of pathAliases) {
-            this.runtime[httpMethod](pathAlias, handler);
-        }
+        this.mountCommon(appManifest, ucd, contract);
+    }
+    mountSync(appManifest, ucd, contract) {
+        this.mountCommon(appManifest, ucd, contract);
     }
     async mountStaticDir(dirPath) {
         this.runtime.use(express.static(dirPath));
     }
     async start() {
-        const host = this.s().server_binding_host;
-        const port = this.s().server_binding_port;
-        this.server.listen(port, host, () => {
-            this.logger.info(`Listening on ${this.entrypointsBuilder.exec().http}`);
-        });
+        listen(this.server, this.entrypointsBuilder, this.logger, this.settingsManager);
     }
     async stop() {
         await stop(this.server);
@@ -125,65 +95,8 @@ let NodeExpressServerManager = class NodeExpressServerManager {
         const credentials = await this.serverSSLCertLoader.exec(undefined);
         this.server = https.createServer(credentials, this.runtime);
     }
-    toFile(f) {
-        return {
-            name: f.name,
-            path: f.tempFilePath,
-            type: f.mimetype,
-        };
-    }
-    toReq(req) {
-        return {
-            bodyFromFormData: async () => {
-                // Since express v5, if the request contains only a file, the `req.body` returns `undefined`
-                const input = req.body ?? {};
-                // files is present when using express-fileupload
-                if ('files' in req && req.files) {
-                    for (const [field, value] of Object.entries(req.files)) {
-                        input[field] = Array.isArray(value)
-                            ? value.map(this.toFile)
-                            : this.toFile(value);
-                    }
-                }
-                for (const [k, v] of Object.entries(input)) {
-                    const isMultiple = k.endsWith('[]'); // e.g. 'tags[]': 'Electronic'
-                    const key = isMultiple ? k.replaceAll('[]', '') : k;
-                    if (isMultiple) {
-                        input[key] = Array.isArray(v) ? v : [v];
-                    }
-                    else {
-                        input[key] = v;
-                    }
-                }
-                return input;
-            },
-            bodyFromJSON: async () => req.body,
-            bodyFromQueryParams: async () => req.query,
-            bodyRaw: req.body,
-            cookie: (name) => req.cookies[name],
-            header: async (name) => {
-                const h = req.headers[name.toLowerCase()];
-                if (Array.isArray(h)) {
-                    this.logger.warn(`Multiple headers found for ${name}. Returning the first one.`);
-                    return h[0];
-                }
-                return h;
-            },
-            method: req.method,
-            secure: req.secure,
-            url: req.url,
-        };
-    }
-    toRes(res) {
-        return {
-            clearCookie: async (name) => {
-                res.clearCookie(name);
-            },
-            redirect: async (location) => res.redirect(location),
-            setCookie: async ({ name, opts, val }) => {
-                res.cookie(name, val, opts);
-            },
-        };
+    mountCommon(appManifest, ucd, contract) {
+        mountHandler(contract, this.runtime, buildHandler(appManifest, ucd, contract, this.serverRequestHandler, this.ucManager));
     }
 };
 NodeExpressServerManager = __decorate([

package/dist/esm/target/node-hono-server/NodeHonoServerManager.d.ts

@@ -1,13 +1,14 @@
-import { Hono } from 'hono';
+import type { Hono } from 'hono';
 import type { AppManifest } from '../../app/index.js';
 import type { DirPath } from '../../dt/index.js';
 import type { Configurable, EnvironmentManager, Logger, SettingsManager } from '../../std/index.js';
 import type { UCDef, UCHTTPContract, UCInput, UCManager, UCOPIBase } from '../../uc/index.js';
 import { EntrypointsBuilder } from '../lib/server/EntrypointsBuilder.js';
-import type { ServerManager, ServerManagerSettings } from '../lib/server/ServerManager.js';
+import type { ServerManager } from '../lib/server/ServerManager.js';
 import { ServerRequestHandler } from '../lib/server/ServerRequestHandler.js';
 import { ServerSSLCertLoader } from '../lib/server/ServerSSLCertLoader.js';
-type S = Pick<ServerManagerSettings, 'server_binding_host' | 'server_binding_port'>;
+import type { ListenSettings } from '../lib/server-node/types.js';
+type S = ListenSettings;
 export declare class NodeHonoServerManager implements Configurable<S>, ServerManager {
     private entrypointsBuilder;
     protected environmentManager: EnvironmentManager;
@@ -23,13 +24,14 @@ export declare class NodeHonoServerManager implements Configurable<S>, ServerMan
     getRuntime(): Hono;
     overrideUCManager(ucManager: UCManager): void;
     init(): Promise<void>;
+    initSync(): void;
     mount<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(appManifest: AppManifest, ucd: UCDef<I, OPI0, OPI1>, contract: UCHTTPContract): Promise<void>;
+    mountSync<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(appManifest: AppManifest, ucd: UCDef<I, OPI0, OPI1>, contract: UCHTTPContract): void;
     mountStaticDir(dirPath: DirPath): Promise<void>;
     start(): Promise<void>;
     stop(): Promise<void>;
     warmUp(): Promise<void>;
     private createServer;
-    private toReq;
-    private toRes;
+    mountCommon<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(appManifest: AppManifest, ucd: UCDef<I, OPI0, OPI1>, contract: UCHTTPContract): void;
 }
 export {};

package/dist/esm/target/node-hono-server/NodeHonoServerManager.js

@@ -12,18 +12,15 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import http from 'node:http';
 import https from 'node:https';
-import { createAdaptorServer, } from '@hono/node-server';
+import { createAdaptorServer } from '@hono/node-server';
 import { serveStatic } from '@hono/node-server/serve-static';
-import { Hono } from 'hono';
-import { deleteCookie, getCookie, setCookie } from 'hono/cookie';
-import { logger } from 'hono/logger';
-import { secureHeaders } from 'hono/secure-headers';
 import { inject, injectable } from 'inversify';
-import { fromFormData } from '../../utils/index.js';
+import { NotCallableError } from '../../error/index.js';
 import { EntrypointsBuilder } from '../lib/server/EntrypointsBuilder.js';
-import { ServerRequestHandler, } from '../lib/server/ServerRequestHandler.js';
+import { ServerRequestHandler } from '../lib/server/ServerRequestHandler.js';
 import { ServerSSLCertLoader } from '../lib/server/ServerSSLCertLoader.js';
-import { stop } from '../lib/server-node/stop.js';
+import { buildHandler, init, mountHandler } from '../lib/server-hono/funcs.js';
+import { listen, stop } from '../lib/server-node/funcs.js';
 let NodeHonoServerManager = class NodeHonoServerManager {
     entrypointsBuilder;
     environmentManager;
@@ -59,50 +56,23 @@ let NodeHonoServerManager = class NodeHonoServerManager {
         this.ucManager = ucManager;
     }
     async init() {
-        this.runtime = new Hono();
-        this.runtime.use(secureHeaders());
-        this.runtime.use(logger());
-        this.runtime.notFound((c) => {
-            return c.json({}, 404);
-        });
+        this.runtime = init();
         await this.createServer();
     }
+    initSync() {
+        throw new NotCallableError('initSync', 'init', 'async-only');
+    }
     async mount(appManifest, ucd, contract) {
-        const { envelope, method, path, pathAliases } = contract;
-        const httpMethod = method.toLowerCase();
-        if (httpMethod === 'connect' ||
-            httpMethod === 'head' ||
-            httpMethod === 'trace') {
-            throw new Error(`Unsupported HTTP method : ${httpMethod}`);
-        }
-        const handler = async (c) => {
-            const { body, status } = await this.serverRequestHandler.exec({
-                appManifest,
-                envelope,
-                req: this.toReq(c),
-                res: this.toRes(c),
-                ucd,
-                ucManager: this.ucManager,
-            });
-            if (!body) {
-                return c.newResponse(null, status);
-            }
-            return c.json(body, status);
-        };
-        this.runtime[httpMethod](path, handler);
-        for (const pathAlias of pathAliases) {
-            this.runtime[httpMethod](pathAlias, handler);
-        }
+        this.mountCommon(appManifest, ucd, contract);
+    }
+    mountSync(appManifest, ucd, contract) {
+        this.mountCommon(appManifest, ucd, contract);
     }
     async mountStaticDir(dirPath) {
         this.runtime.use(serveStatic({ root: dirPath }));
     }
     async start() {
-        const host = this.s().server_binding_host;
-        const port = this.s().server_binding_port;
-        this.server.listen(port, host, () => {
-            this.logger.info(`Listening on ${this.entrypointsBuilder.exec().http}`);
-        });
+        listen(this.server, this.entrypointsBuilder, this.logger, this.settingsManager);
     }
     async stop() {
         await stop(this.server);
@@ -129,29 +99,8 @@ let NodeHonoServerManager = class NodeHonoServerManager {
         opts.serverOptions = await this.serverSSLCertLoader.exec(undefined);
         this.server = createAdaptorServer(opts);
     }
-    toReq(c) {
-        return {
-            bodyFromFormData: async () => fromFormData(await c.req.formData()),
-            bodyFromJSON: () => c.req.json(),
-            bodyFromQueryParams: async () => c.req.queries(),
-            bodyRaw: c.req.raw,
-            cookie: async (name) => getCookie(c, name),
-            header: async (name) => c.req.header(name),
-            method: c.req.method,
-            secure: c.req.url.startsWith('https://'),
-            url: c.req.url,
-        };
-    }
-    toRes(c) {
-        return {
-            clearCookie: async (name) => {
-                deleteCookie(c, name);
-            },
-            redirect: async (location) => {
-                c.redirect(location);
-            },
-            setCookie: async ({ name, opts, val }) => setCookie(c, name, val, opts),
-        };
+    mountCommon(appManifest, ucd, contract) {
+        mountHandler(contract, this.runtime, buildHandler(appManifest, ucd, contract, this.serverRequestHandler, this.ucManager));
     }
 };
 NodeHonoServerManager = __decorate([

package/dist/esm/target/node-mcp-server/NodeLocalStdioMCPServerManager.d.ts

@@ -31,12 +31,16 @@ export declare class NodeLocalStdioMCPServerManager implements Configurable<S>,
     s(): S;
     overrideUCManager(ucManager: UCManager): void;
     init(): Promise<void>;
-    mount<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(appManifest: AppManifest, ucd: UCDef<I, OPI0, OPI1>, _contract: UCHTTPContract): Promise<void>;
+    initSync(): void;
+    mount<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(appManifest: AppManifest, ucd: UCDef<I, OPI0, OPI1>, contract: UCHTTPContract): Promise<void>;
+    mountSync<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(appManifest: AppManifest, ucd: UCDef<I, OPI0, OPI1>, contract: UCHTTPContract): void;
     mountStaticDir(_dirPath: DirPath): Promise<void>;
     start(): Promise<void>;
     stop(): Promise<void>;
     warmUp(): Promise<void>;
     private buildInputSchema;
     private execRequest;
+    private initCommon;
+    mountCommon<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(appManifest: AppManifest, ucd: UCDef<I, OPI0, OPI1>, _contract: UCHTTPContract): void;
 }
 export {};

package/dist/esm/target/node-mcp-server/NodeLocalStdioMCPServerManager.js

@@ -14,6 +14,7 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { inject, injectable } from 'inversify';
+import { NotAvailableError } from '../../error/index.js';
 import { WordingManager } from '../../i18n/index.js';
 import { UCBuilder, ucifIsMandatory, ucMountingPoint, } from '../../uc/index.js';
 import { propertyType, resError, resObj } from './funcs.js';
@@ -55,38 +56,19 @@ let NodeLocalStdioMCPServerManager = class NodeLocalStdioMCPServerManager {
         this.ucManager = ucManager;
     }
     async init() {
-        this.runtime = new Server({
-            name: this.productManifest.name,
-            version: '0.1.0',
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
-        if (this.s().logger_level !== 'error') {
-            const message = 'Set the logging_level to "error" as MCP does not want the server to log to stdout (see https://modelcontextprotocol.io/docs/tools/debugging#implementing-logging)';
-            // Depending on the `Logger` implementation, this.logger.error() might not write to stderr (e.g. can write to a file).
-            // That's why we explicitly write to stdout by calling console.error().
-            // biome-ignore lint/suspicious/noConsole: we want it
-            console.error(new Error(message));
-        }
+        this.initCommon();
     }
-    async mount(appManifest, ucd, _contract) {
-        const uc = this.ucBuilder.exec({
-            appManifest,
-            auth: null,
-            def: ucd,
-        });
-        if (!this.appManifests.has(appManifest.name)) {
-            this.appManifests.set(appManifest.name, appManifest);
-        }
-        const inputSchema = this.buildInputSchema(uc);
-        const mountingPoint = uc.def.ext?.cmd?.mountAt ?? ucMountingPoint(uc);
-        const tool = { inputSchema, name: mountingPoint };
-        this.tools.set(mountingPoint, { appName: appManifest.name, tool, ucd });
+    initSync() {
+        this.initCommon();
+    }
+    async mount(appManifest, ucd, contract) {
+        this.mountCommon(appManifest, ucd, contract);
+    }
+    mountSync(appManifest, ucd, contract) {
+        this.mountCommon(appManifest, ucd, contract);
     }
     async mountStaticDir(_dirPath) {
-        throw new Error('Method not implemented.');
+        throw new NotAvailableError('mountStaticDir');
     }
     async start() {
         this.transport = new StdioServerTransport();
@@ -156,6 +138,37 @@ let NodeLocalStdioMCPServerManager = class NodeLocalStdioMCPServerManager {
             return resError(err);
         }
     }
+    initCommon() {
+        this.runtime = new Server({
+            name: this.productManifest.name,
+            version: '0.1.0',
+        }, {
+            capabilities: {
+                tools: {},
+            },
+        });
+        if (this.s().logger_level !== 'error') {
+            const message = 'Set the logging_level to "error" as MCP does not want the server to log to stdout (see https://modelcontextprotocol.io/docs/tools/debugging#implementing-logging)';
+            // Depending on the `Logger` implementation, this.logger.error() might not write to stderr (e.g. can write to a file).
+            // That's why we explicitly write to stdout by calling console.error().
+            // biome-ignore lint/suspicious/noConsole: we want it
+            console.error(new Error(message));
+        }
+    }
+    mountCommon(appManifest, ucd, _contract) {
+        const uc = this.ucBuilder.exec({
+            appManifest,
+            auth: null,
+            def: ucd,
+        });
+        if (!this.appManifests.has(appManifest.name)) {
+            this.appManifests.set(appManifest.name, appManifest);
+        }
+        const inputSchema = this.buildInputSchema(uc);
+        const mountingPoint = uc.def.ext?.cmd?.mountAt ?? ucMountingPoint(uc);
+        const tool = { inputSchema, name: mountingPoint };
+        this.tools.set(mountingPoint, { appName: appManifest.name, tool, ucd });
+    }
 };
 NodeLocalStdioMCPServerManager = __decorate([
     injectable(),

package/dist/esm/testing/UCDataStoreTester.js

@@ -16,7 +16,7 @@ import { APP_NAME_PLACEHOLDER } from '../convention.js';
 import { TAmount, TCompanyName, } from '../dt/index.js';
 import { UCExecMode, } from '../uc/index.js';
 const ERR_SHOULD_NOT_EXIST_AFTER_DESTROY = 'It should not exist after destroy';
-const ERR_SHOULD_EXIST_AFTER_INSTALL = 'It should exist after install';
+const ERR_SHOULD_EXIST_AFTER_INIT = 'It should exist after init';
 const ERR_SHOULD_RETURN_X_RECORDS = (n) => `It should return ${n} record(s)`;
 /**
  * Test that a {@link UCDataStore} conforms to the spec
@@ -52,10 +52,10 @@ let UCDataStoreTester = class UCDataStoreTester {
         if (this.exists) {
             throw new Error(ERR_SHOULD_NOT_EXIST_AFTER_DESTROY);
         }
-        await ucDataStore.install();
+        await ucDataStore.init();
         this.exists = await ucDataStore.exists();
         if (!this.exists) {
-            throw new Error(ERR_SHOULD_EXIST_AFTER_INSTALL);
+            throw new Error(ERR_SHOULD_EXIST_AFTER_INIT);
         }
         this.readRes = await ucDataStore.read();
         this.expectXRecords(0);

package/dist/esm/uc/data-store.d.ts

@@ -1,6 +1,6 @@
 import type { AppName } from '../app/index.js';
 import type { UIntQuantity, UUID } from '../dt/index.js';
-import type { Clearable, StringKeys } from '../utils/index.js';
+import type { Clearable, Initializable, StringKeys } from '../utils/index.js';
 import type { UCData } from './data.js';
 import type { UCExecMode } from './exec.js';
 import type { UCInput } from './input.js';
@@ -55,13 +55,12 @@ export interface UCDataStoreRecord<I extends UCInput | undefined = undefined, D
     organizationId: UUID | null;
     userId: UUID | null;
 }
-export interface UCDataStore extends Clearable {
+export interface UCDataStore extends Clearable, Initializable {
     destroy(): Promise<void>;
     exists(): Promise<boolean>;
-    initTx(): Promise<UCDataStoreTx['ref']>;
-    install(): Promise<void>;
     read<I extends UCInput | undefined = undefined, D extends UCData | null = null>(opts?: UCDataStoreReadOpts<I, D>): Promise<UCDataStoreReadResponse<I, D>>;
     readProjection<T extends object>(name: string, opts?: UCDataStoreReadProjectionOpts<T>): Promise<T[]>;
+    startTx(): Promise<UCDataStoreTx['ref']>;
     supportedSpecificBindings(): UCDataStoreWriteProjectionSpecificBinding[];
     testKey(encryptionKey: Uint8Array): Promise<void>;
     write<I extends UCInput | undefined = undefined, D extends UCData | null = null>(record: UCDataStoreRecord<I, D>, opts?: UCDataStoreWriteOpts): Promise<void>;

package/dist/esm/uc/helpers/UCOutputBuilder.js

@@ -51,6 +51,7 @@ export class UCOutputBuilder {
         const idx = this.output.parts._0.items.findIndex(predicate);
         if (idx > -1) {
             this.output.parts._0.items.splice(idx, 1);
+            this.output.parts._0.total -= 1;
         }
         return this;
     }

package/dist/esm/uc/impl/CloudflareD1UCDataStore.d.ts

@@ -0,0 +1,34 @@
+import type { D1Database } from '@cloudflare/workers-types';
+import type { Configurable, SettingsManager } from '../../std/index.js';
+import type { UCData } from '../data.js';
+import type { UCDataStore, UCDataStoreReadOpts, UCDataStoreReadProjectionOpts, UCDataStoreReadResponse, UCDataStoreRecord, UCDataStoreTx, UCDataStoreWriteOpts, UCDataStoreWriteProjectionOpts, UCDataStoreWriteProjectionSpecificBinding } from '../data-store.js';
+import type { UCInput } from '../input.js';
+import type { UCSettings } from '../settings.js';
+type S = Pick<UCSettings, 'uc_data_store_ucs_dataset_name'>;
+export declare const ROW_COLS: (keyof UCDataStoreRecord)[];
+/**
+ * @alpha This implementation is still a WIP and needs improvement
+ */
+export declare class CloudflareD1UCDataStore implements Configurable<S>, UCDataStore {
+    protected settingsManager: SettingsManager<S>;
+    protected client?: D1Database | undefined;
+    constructor(settingsManager: SettingsManager<S>);
+    s(): S;
+    clear(): Promise<void>;
+    destroy(): Promise<void>;
+    exists(): Promise<boolean>;
+    init(): Promise<void>;
+    initSync(): void;
+    read<I extends UCInput | undefined = undefined, D extends UCData | null = null>(opts?: UCDataStoreReadOpts<I, D>): Promise<UCDataStoreReadResponse<I, D>>;
+    readProjection<T extends object>(_name: string, _opts?: UCDataStoreReadProjectionOpts<T>): Promise<T[]>;
+    startTx(): Promise<UCDataStoreTx['ref']>;
+    supportedSpecificBindings(): UCDataStoreWriteProjectionSpecificBinding[];
+    testKey(_encryptionKey: Uint8Array): Promise<void>;
+    write<I extends UCInput | undefined = undefined, D extends UCData | null = null>(record: UCDataStoreRecord<I, D>, _opts?: UCDataStoreWriteOpts): Promise<void>;
+    writeBulk<I extends UCInput | undefined = undefined, D extends UCData | null = null>(_records: UCDataStoreRecord<I, D>[], _opts?: UCDataStoreWriteOpts): Promise<void>;
+    writeProjection<T extends object>(_name: string, _data: T, _opts?: UCDataStoreWriteProjectionOpts): Promise<void>;
+    setClient(client: D1Database): void;
+    private assertClient;
+    private filter;
+}
+export {};