quidproquo-actionprocessor-node 0.1.3 → 0.1.4

package/lib/esm/dynamicActionProcessor/file/getFileReadTextContentsActionProcessor.js

@@ -18,3 +18,4 @@ const getProcessFileReadTextContents = (qpqConfig, config) => {
 export const getFileReadTextContentsActionProcessor = (config) => async (qpqConfig) => ({
     [FileActionType.ReadTextContents]: getProcessFileReadTextContents(qpqConfig, config),
 });
+//# sourceMappingURL=getFileReadTextContentsActionProcessor.js.map

package/lib/esm/dynamicActionProcessor/file/getFileReadTextContentsActionProcessor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getFileReadTextContentsActionProcessor.js","sourceRoot":"","sources":["../../../../src/dynamicActionProcessor/file/getFileReadTextContentsActionProcessor.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,YAAY,EACZ,iBAAiB,EACjB,gCAAgC,EAChC,aAAa,EACb,cAAc,GAGf,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAE,MAAM,aAAa,CAAC;AAGlC,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE1C,MAAM,8BAA8B,GAAG,CAAC,SAAoB,EAAE,MAAyB,EAAuC,EAAE;IAC9H,OAAO,KAAK,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,EAAE,EAAE;QACnC,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,eAAe,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;YACrE,MAAM,OAAO,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;YACpD,OAAO,YAAY,CAAC,OAAO,CAAC,CAAC;QAC/B,CAAC;QAAC,OAAO,KAAc,EAAE,CAAC;YACxB,OAAO,gCAAgC,CAAC,KAAK,EAAE;gBAC7C,MAAM,EAAE,GAAG,EAAE,CAAC,iBAAiB,CAAC,aAAa,CAAC,QAAQ,EAAE,mBAAmB,QAAQ,EAAE,CAAC,EAAE,eAAe;aACxG,CAAC,CAAC;QACL,CAAC;IACH,CAAC,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,sCAAsC,GACjD,CAAC,MAAyB,EAA+B,EAAE,CAC3D,KAAK,EAAE,SAAoB,EAAgC,EAAE,CAAC,CAAC;IAC7D,CAAC,cAAc,CAAC,gBAAgB,CAAC,EAAE,8BAA8B,CAAC,SAAS,EAAE,MAAM,CAAC;CACrF,CAAC,CAAC","sourcesContent":["import {\n  ActionProcessorList,\n  ActionProcessorListResolver,\n  actionResult,\n  actionResultError,\n  actionResultErrorFromCaughtError,\n  ErrorTypeEnum,\n  FileActionType,\n  FileReadTextContentsActionProcessor,\n  QPQConfig,\n} from 'quidproquo-core';\n\nimport * as fs from 'fs/promises';\n\nimport { FileStorageConfig } from './types';\nimport { resolveFilePath } from './utils';\n\nconst getProcessFileReadTextContents = (qpqConfig: QPQConfig, config: FileStorageConfig): FileReadTextContentsActionProcessor => {\n  return async ({ drive, filepath }) => {\n    try {\n      const fullPath = resolveFilePath(config, qpqConfig, drive, filepath);\n      const content = await fs.readFile(fullPath, 'utf8');\n      return actionResult(content);\n    } catch (error: unknown) {\n      return actionResultErrorFromCaughtError(error, {\n        ENOENT: () => actionResultError(ErrorTypeEnum.NotFound, `File not found: ${filepath}`), // node fs code\n      });\n    }\n  };\n};\n\nexport const getFileReadTextContentsActionProcessor =\n  (config: FileStorageConfig): ActionProcessorListResolver =>\n  async (qpqConfig: QPQConfig): Promise<ActionProcessorList> => ({\n    [FileActionType.ReadTextContents]: getProcessFileReadTextContents(qpqConfig, config),\n  });\n"]}

package/lib/esm/dynamicActionProcessor/file/getFileStreamOpenActionProcessor.js

@@ -35,3 +35,4 @@ const getProcessFileStreamOpen = (qpqConfig, config) => {
 export const getFileStreamOpenActionProcessor = (config) => async (qpqConfig) => ({
     [FileActionType.StreamOpen]: getProcessFileStreamOpen(qpqConfig, config),
 });
+//# sourceMappingURL=getFileStreamOpenActionProcessor.js.map

package/lib/esm/dynamicActionProcessor/file/getFileStreamOpenActionProcessor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getFileStreamOpenActionProcessor.js","sourceRoot":"","sources":["../../../../src/dynamicActionProcessor/file/getFileStreamOpenActionProcessor.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,YAAY,EACZ,iBAAiB,EACjB,gCAAgC,EAChC,cAAc,EAEd,2BAA2B,GAE5B,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AACpC,OAAO,KAAK,EAAE,MAAM,IAAI,CAAC;AAIzB,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE1C,KAAK,SAAS,CAAC,CAAC,kBAAkB,CAAC,MAAgB;IACjD,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QACjC,MAAM,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAE,KAAgB,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC/E,CAAC;AACH,CAAC;AAED,KAAK,SAAS,CAAC,CAAC,oBAAoB,CAAC,MAAgB;IACnD,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QACjC,MAAM,MAAM,GAAG,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAE,KAAgB,CAAC;QAClF,MAAM,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IAClC,CAAC;AACH,CAAC;AAED,MAAM,wBAAwB,GAAG,CAAC,SAAoB,EAAE,MAAyB,EAAiC,EAAE;IAClH,OAAO,KAAK,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,EAAE,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,aAAa,EAAE,mBAAmB,EAAE,cAAc,EAAE,EAAE;QAC/I,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,eAAe,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;YACrE,MAAM,MAAM,GAAG,QAAQ,KAAK,MAAM,CAAC;YACnC,MAAM,aAAa,GAAG,SAAS,IAAI,KAAK,CAAC;YACzC,MAAM,UAAU,GAAG,EAAE,CAAC,gBAAgB,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,CAAC,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,CAAC;YACnH,MAAM,QAAQ,GAAG,QAAQ,UAAU,EAAE,EAAE,CAAC;YAExC,MAAM,QAAQ,GAAG,MAAM,CAAC,CAAC,CAAC,kBAAkB,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,oBAAoB,CAAC,UAAU,CAAC,CAAC;YAC5F,cAAc,CAAC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;YAE5C,OAAO,YAAY,CAAC,EAAE,EAAE,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC,CAAC;QAClD,CAAC;QAAC,OAAO,KAAc,EAAE,CAAC;YACxB,OAAO,gCAAgC,CAAC,KAAK,EAAE;gBAC7C,MAAM,EAAE,GAAG,EAAE,CAAC,iBAAiB,CAAC,2BAA2B,CAAC,YAAY,EAAE,mBAAmB,QAAQ,EAAE,CAAC,EAAE,eAAe;aAC1H,CAAC,CAAC;QACL,CAAC;IACH,CAAC,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,gCAAgC,GAC3C,CAAC,MAAyB,EAA+B,EAAE,CAC3D,KAAK,EAAE,SAAoB,EAAgC,EAAE,CAAC,CAAC;IAC7D,CAAC,cAAc,CAAC,UAAU,CAAC,EAAE,wBAAwB,CAAC,SAAS,EAAE,MAAM,CAAC;CACzE,CAAC,CAAC","sourcesContent":["import {\n  ActionProcessorList,\n  ActionProcessorListResolver,\n  actionResult,\n  actionResultError,\n  actionResultErrorFromCaughtError,\n  FileActionType,\n  FileStreamOpenActionProcessor,\n  FileStreamOpenErrorTypeEnum,\n  QPQConfig,\n} from 'quidproquo-core';\n\nimport { randomUUID } from 'crypto';\nimport * as fs from 'fs';\nimport { Readable } from 'stream';\n\nimport { FileStorageConfig } from './types';\nimport { resolveFilePath } from './utils';\n\nasync function* textStreamIterator(stream: Readable): AsyncIterableIterator<string> {\n  for await (const chunk of stream) {\n    yield typeof chunk === 'string' ? chunk : (chunk as Buffer).toString('utf8');\n  }\n}\n\nasync function* binaryStreamIterator(stream: Readable): AsyncIterableIterator<string> {\n  for await (const chunk of stream) {\n    const buffer = typeof chunk === 'string' ? Buffer.from(chunk) : (chunk as Buffer);\n    yield buffer.toString('base64');\n  }\n}\n\nconst getProcessFileStreamOpen = (qpqConfig: QPQConfig, config: FileStorageConfig): FileStreamOpenActionProcessor => {\n  return async ({ drive, filepath, encoding, chunkSize }, session, actionProcessors, logger, updateSession, dynamicModuleLoader, streamRegistry) => {\n    try {\n      const fullPath = resolveFilePath(config, qpqConfig, drive, filepath);\n      const isText = encoding === 'text';\n      const highWaterMark = chunkSize ?? 65536;\n      const readStream = fs.createReadStream(fullPath, isText ? { encoding: 'utf8', highWaterMark } : { highWaterMark });\n      const streamId = `file-${randomUUID()}`;\n\n      const iterator = isText ? textStreamIterator(readStream) : binaryStreamIterator(readStream);\n      streamRegistry.register(streamId, iterator);\n\n      return actionResult({ id: streamId, encoding });\n    } catch (error: unknown) {\n      return actionResultErrorFromCaughtError(error, {\n        ENOENT: () => actionResultError(FileStreamOpenErrorTypeEnum.FileNotFound, `File not found: ${filepath}`), // node fs code\n      });\n    }\n  };\n};\n\nexport const getFileStreamOpenActionProcessor =\n  (config: FileStorageConfig): ActionProcessorListResolver =>\n  async (qpqConfig: QPQConfig): Promise<ActionProcessorList> => ({\n    [FileActionType.StreamOpen]: getProcessFileStreamOpen(qpqConfig, config),\n  });\n"]}

package/lib/esm/dynamicActionProcessor/file/getFileWriteBinaryContentsActionProcessor.js

@@ -27,3 +27,4 @@ const getProcessFileWriteBinaryContents = (config) => (qpqConfig) => {
 export const getFileWriteBinaryContentsActionProcessor = (config) => async (qpqConfig) => ({
     [FileActionType.WriteBinaryContents]: getProcessFileWriteBinaryContents(config)(qpqConfig),
 });
+//# sourceMappingURL=getFileWriteBinaryContentsActionProcessor.js.map

package/lib/esm/dynamicActionProcessor/file/getFileWriteBinaryContentsActionProcessor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getFileWriteBinaryContentsActionProcessor.js","sourceRoot":"","sources":["../../../../src/dynamicActionProcessor/file/getFileWriteBinaryContentsActionProcessor.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,YAAY,EACZ,iBAAiB,EACjB,gCAAgC,EAChC,cAAc,EAEd,oCAAoC,GAErC,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAE,MAAM,aAAa,CAAC;AAGlC,OAAO,EAAE,2BAA2B,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAEvE,MAAM,iCAAiC,GACrC,CAAC,MAAyB,EAAE,EAAE,CAC9B,CAAC,SAAoB,EAA0C,EAAE;IAC/D,OAAO,KAAK,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,EAAE;QACzC,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,eAAe,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;YACrE,MAAM,2BAA2B,CAAC,QAAQ,CAAC,CAAC;YAE5C,kCAAkC;YAClC,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;YACtD,MAAM,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;YAErC,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC;gBAC7C,MAAM,EAAE,CAAC,SAAS,CAChB,GAAG,QAAQ,eAAe,EAC1B,IAAI,CAAC,SAAS,CAAC;oBACb,QAAQ,EAAE,IAAI,CAAC,QAAQ;oBACvB,kBAAkB,EAAE,IAAI,CAAC,kBAAkB;iBAC5C,CAAC,CACH,CAAC;YACJ,CAAC;YAED,OAAO,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;QAC9B,CAAC;QAAC,OAAO,KAAc,EAAE,CAAC;YACxB,OAAO,gCAAgC,CAAC,KAAK,EAAE;gBAC7C,MAAM,EAAE,GAAG,EAAE,CAAC,iBAAiB,CAAC,oCAAoC,CAAC,YAAY,EAAE,+BAA+B,QAAQ,EAAE,CAAC,EAAE,eAAe;aAC/I,CAAC,CAAC;QACL,CAAC;IACH,CAAC,CAAC;AACJ,CAAC,CAAC;AAEJ,MAAM,CAAC,MAAM,yCAAyC,GACpD,CAAC,MAAyB,EAA+B,EAAE,CAC3D,KAAK,EAAE,SAAoB,EAAgC,EAAE,CAAC,CAAC;IAC7D,CAAC,cAAc,CAAC,mBAAmB,CAAC,EAAE,iCAAiC,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC;CAC3F,CAAC,CAAC","sourcesContent":["import {\n  ActionProcessorList,\n  ActionProcessorListResolver,\n  actionResult,\n  actionResultError,\n  actionResultErrorFromCaughtError,\n  FileActionType,\n  FileWriteBinaryContentsActionProcessor,\n  FileWriteBinaryContentsErrorTypeEnum,\n  QPQConfig,\n} from 'quidproquo-core';\n\nimport * as fs from 'fs/promises';\n\nimport { FileStorageConfig } from './types';\nimport { ensureParentDirectoryExists, resolveFilePath } from './utils';\n\nconst getProcessFileWriteBinaryContents =\n  (config: FileStorageConfig) =>\n  (qpqConfig: QPQConfig): FileWriteBinaryContentsActionProcessor => {\n    return async ({ drive, filepath, data }) => {\n      try {\n        const fullPath = resolveFilePath(config, qpqConfig, drive, filepath);\n        await ensureParentDirectoryExists(fullPath);\n\n        // Convert QPQBinaryData to Buffer\n        const buffer = Buffer.from(data.base64Data, 'base64');\n        await fs.writeFile(fullPath, buffer);\n\n        if (data.mimetype || data.contentDisposition) {\n          await fs.writeFile(\n            `${fullPath}.qpqmeta.json`,\n            JSON.stringify({\n              mimetype: data.mimetype,\n              contentDisposition: data.contentDisposition,\n            }),\n          );\n        }\n\n        return actionResult(void 0);\n      } catch (error: unknown) {\n        return actionResultErrorFromCaughtError(error, {\n          EACCES: () => actionResultError(FileWriteBinaryContentsErrorTypeEnum.AccessDenied, `Access denied writing file: ${filepath}`), // node fs code\n        });\n      }\n    };\n  };\n\nexport const getFileWriteBinaryContentsActionProcessor =\n  (config: FileStorageConfig): ActionProcessorListResolver =>\n  async (qpqConfig: QPQConfig): Promise<ActionProcessorList> => ({\n    [FileActionType.WriteBinaryContents]: getProcessFileWriteBinaryContents(config)(qpqConfig),\n  });\n"]}

package/lib/esm/dynamicActionProcessor/file/getFileWriteObjectJsonActionProcessor.js

@@ -20,3 +20,4 @@ const getProcessFileWriteObjectJson = (config) => (qpqConfig) => {
 export const getFileWriteObjectJsonActionProcessor = (config) => async (qpqConfig) => ({
     [FileActionType.WriteObjectJson]: getProcessFileWriteObjectJson(config)(qpqConfig),
 });
+//# sourceMappingURL=getFileWriteObjectJsonActionProcessor.js.map

package/lib/esm/dynamicActionProcessor/file/getFileWriteObjectJsonActionProcessor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getFileWriteObjectJsonActionProcessor.js","sourceRoot":"","sources":["../../../../src/dynamicActionProcessor/file/getFileWriteObjectJsonActionProcessor.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,YAAY,EACZ,iBAAiB,EACjB,gCAAgC,EAChC,cAAc,EAEd,gCAAgC,GAEjC,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAE,MAAM,aAAa,CAAC;AAGlC,OAAO,EAAE,2BAA2B,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAEvE,MAAM,6BAA6B,GACjC,CAAC,MAAyB,EAAE,EAAE,CAC9B,CAAC,SAAoB,EAA2C,EAAE;IAChE,OAAO,KAAK,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,EAAE;QACzC,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,eAAe,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;YACrE,MAAM,2BAA2B,CAAC,QAAQ,CAAC,CAAC;YAC5C,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;YACjD,MAAM,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;YACjD,OAAO,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;QAC9B,CAAC;QAAC,OAAO,KAAc,EAAE,CAAC;YACxB,OAAO,gCAAgC,CAAC,KAAK,EAAE;gBAC7C,MAAM,EAAE,GAAG,EAAE,CAAC,iBAAiB,CAAC,gCAAgC,CAAC,YAAY,EAAE,+BAA+B,QAAQ,EAAE,CAAC,EAAE,eAAe;aAC3I,CAAC,CAAC;QACL,CAAC;IACH,CAAC,CAAC;AACJ,CAAC,CAAC;AAEJ,MAAM,CAAC,MAAM,qCAAqC,GAChD,CAAC,MAAyB,EAA+B,EAAE,CAC3D,KAAK,EAAE,SAAoB,EAAgC,EAAE,CAAC,CAAC;IAC7D,CAAC,cAAc,CAAC,eAAe,CAAC,EAAE,6BAA6B,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC;CACnF,CAAC,CAAC","sourcesContent":["import {\n  ActionProcessorList,\n  ActionProcessorListResolver,\n  actionResult,\n  actionResultError,\n  actionResultErrorFromCaughtError,\n  FileActionType,\n  FileWriteObjectJsonActionProcessor,\n  FileWriteObjectJsonErrorTypeEnum,\n  QPQConfig,\n} from 'quidproquo-core';\n\nimport * as fs from 'fs/promises';\n\nimport { FileStorageConfig } from './types';\nimport { ensureParentDirectoryExists, resolveFilePath } from './utils';\n\nconst getProcessFileWriteObjectJson =\n  (config: FileStorageConfig) =>\n  (qpqConfig: QPQConfig): FileWriteObjectJsonActionProcessor<any> => {\n    return async ({ drive, filepath, data }) => {\n      try {\n        const fullPath = resolveFilePath(config, qpqConfig, drive, filepath);\n        await ensureParentDirectoryExists(fullPath);\n        const jsonString = JSON.stringify(data, null, 2);\n        await fs.writeFile(fullPath, jsonString, 'utf8');\n        return actionResult(void 0);\n      } catch (error: unknown) {\n        return actionResultErrorFromCaughtError(error, {\n          EACCES: () => actionResultError(FileWriteObjectJsonErrorTypeEnum.AccessDenied, `Access denied writing file: ${filepath}`), // node fs code\n        });\n      }\n    };\n  };\n\nexport const getFileWriteObjectJsonActionProcessor =\n  (config: FileStorageConfig): ActionProcessorListResolver =>\n  async (qpqConfig: QPQConfig): Promise<ActionProcessorList> => ({\n    [FileActionType.WriteObjectJson]: getProcessFileWriteObjectJson(config)(qpqConfig),\n  });\n"]}

package/lib/esm/dynamicActionProcessor/file/getFileWriteTextContentsActionProcessor.js

@@ -19,3 +19,4 @@ const getProcessFileWriteTextContents = (qpqConfig, config) => {
 export const getFileWriteTextContentsActionProcessor = (config) => async (qpqConfig) => ({
     [FileActionType.WriteTextContents]: getProcessFileWriteTextContents(qpqConfig, config),
 });
+//# sourceMappingURL=getFileWriteTextContentsActionProcessor.js.map

package/lib/esm/dynamicActionProcessor/file/getFileWriteTextContentsActionProcessor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getFileWriteTextContentsActionProcessor.js","sourceRoot":"","sources":["../../../../src/dynamicActionProcessor/file/getFileWriteTextContentsActionProcessor.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,YAAY,EACZ,iBAAiB,EACjB,gCAAgC,EAChC,cAAc,EAEd,kCAAkC,GAEnC,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAE,MAAM,aAAa,CAAC;AAGlC,OAAO,EAAE,2BAA2B,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAEvE,MAAM,+BAA+B,GAAG,CAAC,SAAoB,EAAE,MAAyB,EAAwC,EAAE;IAChI,OAAO,KAAK,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,EAAE;QACzC,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,eAAe,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;YACrE,MAAM,2BAA2B,CAAC,QAAQ,CAAC,CAAC;YAC5C,MAAM,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;YAC3C,OAAO,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;QAC9B,CAAC;QAAC,OAAO,KAAc,EAAE,CAAC;YACxB,OAAO,gCAAgC,CAAC,KAAK,EAAE;gBAC7C,MAAM,EAAE,GAAG,EAAE,CAAC,iBAAiB,CAAC,kCAAkC,CAAC,YAAY,EAAE,+BAA+B,QAAQ,EAAE,CAAC,EAAE,eAAe;aAC7I,CAAC,CAAC;QACL,CAAC;IACH,CAAC,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,uCAAuC,GAClD,CAAC,MAAyB,EAA+B,EAAE,CAC3D,KAAK,EAAE,SAAoB,EAAgC,EAAE,CAAC,CAAC;IAC7D,CAAC,cAAc,CAAC,iBAAiB,CAAC,EAAE,+BAA+B,CAAC,SAAS,EAAE,MAAM,CAAC;CACvF,CAAC,CAAC","sourcesContent":["import {\n  ActionProcessorList,\n  ActionProcessorListResolver,\n  actionResult,\n  actionResultError,\n  actionResultErrorFromCaughtError,\n  FileActionType,\n  FileWriteTextContentsActionProcessor,\n  FileWriteTextContentsErrorTypeEnum,\n  QPQConfig,\n} from 'quidproquo-core';\n\nimport * as fs from 'fs/promises';\n\nimport { FileStorageConfig } from './types';\nimport { ensureParentDirectoryExists, resolveFilePath } from './utils';\n\nconst getProcessFileWriteTextContents = (qpqConfig: QPQConfig, config: FileStorageConfig): FileWriteTextContentsActionProcessor => {\n  return async ({ drive, filepath, data }) => {\n    try {\n      const fullPath = resolveFilePath(config, qpqConfig, drive, filepath);\n      await ensureParentDirectoryExists(fullPath);\n      await fs.writeFile(fullPath, data, 'utf8');\n      return actionResult(void 0);\n    } catch (error: unknown) {\n      return actionResultErrorFromCaughtError(error, {\n        EACCES: () => actionResultError(FileWriteTextContentsErrorTypeEnum.AccessDenied, `Access denied writing file: ${filepath}`), // node fs code\n      });\n    }\n  };\n};\n\nexport const getFileWriteTextContentsActionProcessor =\n  (config: FileStorageConfig): ActionProcessorListResolver =>\n  async (qpqConfig: QPQConfig): Promise<ActionProcessorList> => ({\n    [FileActionType.WriteTextContents]: getProcessFileWriteTextContents(qpqConfig, config),\n  });\n"]}

package/lib/esm/dynamicActionProcessor/file/index.js

@@ -32,3 +32,4 @@ export const getFileActionProcessor = (fileStorageConfig) => {
 };
 export * from './secureUrlUtils';
 export * from './utils';
+//# sourceMappingURL=index.js.map

package/lib/esm/dynamicActionProcessor/file/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/dynamicActionProcessor/file/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,4BAA4B,EAAE,MAAM,gCAAgC,CAAC;AAC9E,OAAO,EAAE,4BAA4B,EAAE,MAAM,gCAAgC,CAAC;AAC9E,OAAO,EAAE,gDAAgD,EAAE,MAAM,oDAAoD,CAAC;AACtH,OAAO,EAAE,sDAAsD,EAAE,MAAM,0DAA0D,CAAC;AAClI,OAAO,EAAE,mCAAmC,EAAE,MAAM,uCAAuC,CAAC;AAC5F,OAAO,EAAE,mCAAmC,EAAE,MAAM,uCAAuC,CAAC;AAC5F,OAAO,EAAE,wCAAwC,EAAE,MAAM,4CAA4C,CAAC;AACtG,OAAO,EAAE,oCAAoC,EAAE,MAAM,wCAAwC,CAAC;AAC9F,OAAO,EAAE,sCAAsC,EAAE,MAAM,0CAA0C,CAAC;AAClG,OAAO,EAAE,gCAAgC,EAAE,MAAM,oCAAoC,CAAC;AACtF,OAAO,EAAE,yCAAyC,EAAE,MAAM,6CAA6C,CAAC;AACxG,OAAO,EAAE,qCAAqC,EAAE,MAAM,yCAAyC,CAAC;AAChG,OAAO,EAAE,uCAAuC,EAAE,MAAM,2CAA2C,CAAC;AAGpG,cAAc,SAAS,CAAC;AAExB,yCAAyC;AACzC,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,iBAAoC,EAA+B,EAAE;IAC1G,OAAO,KAAK,EAAE,SAAoB,EAAE,mBAAwC,EAAgC,EAAE,CAAC,CAAC;QAC9G,GAAG,CAAC,MAAM,sCAAsC,CAAC,iBAAiB,CAAC,CAAC,SAAS,EAAE,mBAAmB,CAAC,CAAC;QACpG,GAAG,CAAC,MAAM,uCAAuC,CAAC,iBAAiB,CAAC,CAAC,SAAS,EAAE,mBAAmB,CAAC,CAAC;QACrG,GAAG,CAAC,MAAM,oCAAoC,CAAC,iBAAiB,CAAC,CAAC,SAAS,EAAE,mBAAmB,CAAC,CAAC;QAClG,GAAG,CAAC,MAAM,qCAAqC,CAAC,iBAAiB,CAAC,CAAC,SAAS,EAAE,mBAAmB,CAAC,CAAC;QACnG,GAAG,CAAC,MAAM,wCAAwC,CAAC,iBAAiB,CAAC,CAAC,SAAS,EAAE,mBAAmB,CAAC,CAAC;QACtG,GAAG,CAAC,MAAM,yCAAyC,CAAC,iBAAiB,CAAC,CAAC,SAAS,EAAE,mBAAmB,CAAC,CAAC;QACvG,GAAG,CAAC,MAAM,mCAAmC,CAAC,iBAAiB,CAAC,CAAC,SAAS,EAAE,mBAAmB,CAAC,CAAC;QACjG,GAAG,CAAC,MAAM,4BAA4B,CAAC,iBAAiB,CAAC,CAAC,SAAS,EAAE,mBAAmB,CAAC,CAAC;QAC1F,GAAG,CAAC,MAAM,4BAA4B,CAAC,iBAAiB,CAAC,CAAC,SAAS,EAAE,mBAAmB,CAAC,CAAC;QAC1F,GAAG,CAAC,MAAM,gDAAgD,CAAC,iBAAiB,CAAC,CAAC,SAAS,EAAE,mBAAmB,CAAC,CAAC;QAC9G,GAAG,CAAC,MAAM,sDAAsD,CAAC,iBAAiB,CAAC,CAAC,SAAS,EAAE,mBAAmB,CAAC,CAAC;QACpH,GAAG,CAAC,MAAM,mCAAmC,CAAC,iBAAiB,CAAC,CAAC,SAAS,EAAE,mBAAmB,CAAC,CAAC;QACjG,GAAG,CAAC,MAAM,gCAAgC,CAAC,iBAAiB,CAAC,CAAC,SAAS,EAAE,mBAAmB,CAAC,CAAC;KAC/F,CAAC,CAAC;AACL,CAAC,CAAC;AAEF,cAAc,kBAAkB,CAAC;AACjC,cAAc,SAAS,CAAC","sourcesContent":["import { ActionProcessorList, ActionProcessorListResolver, DynamicModuleLoader, QPQConfig } from 'quidproquo-core';\n\nimport { getFileDeleteActionProcessor } from './getFileDeleteActionProcessor';\nimport { getFileExistsActionProcessor } from './getFileExistsActionProcessor';\nimport { getFileGenerateTemporarySecureUrlActionProcessor } from './getFileGenerateTemporarySecureUrlActionProcessor';\nimport { getFileGenerateTemporaryUploadSecureUrlActionProcessor } from './getFileGenerateTemporaryUploadSecureUrlActionProcessor';\nimport { getFileIsColdStorageActionProcessor } from './getFileIsColdStorageActionProcessor';\nimport { getFileListDirectoryActionProcessor } from './getFileListDirectoryActionProcessor';\nimport { getFileReadBinaryContentsActionProcessor } from './getFileReadBinaryContentsActionProcessor';\nimport { getFileReadObjectJsonActionProcessor } from './getFileReadObjectJsonActionProcessor';\nimport { getFileReadTextContentsActionProcessor } from './getFileReadTextContentsActionProcessor';\nimport { getFileStreamOpenActionProcessor } from './getFileStreamOpenActionProcessor';\nimport { getFileWriteBinaryContentsActionProcessor } from './getFileWriteBinaryContentsActionProcessor';\nimport { getFileWriteObjectJsonActionProcessor } from './getFileWriteObjectJsonActionProcessor';\nimport { getFileWriteTextContentsActionProcessor } from './getFileWriteTextContentsActionProcessor';\nimport { FileStorageConfig } from './types';\n\nexport * from './types';\n\n// Main export that accepts configuration\nexport const getFileActionProcessor = (fileStorageConfig: FileStorageConfig): ActionProcessorListResolver => {\n  return async (qpqConfig: QPQConfig, dynamicModuleLoader: DynamicModuleLoader): Promise<ActionProcessorList> => ({\n    ...(await getFileReadTextContentsActionProcessor(fileStorageConfig)(qpqConfig, dynamicModuleLoader)),\n    ...(await getFileWriteTextContentsActionProcessor(fileStorageConfig)(qpqConfig, dynamicModuleLoader)),\n    ...(await getFileReadObjectJsonActionProcessor(fileStorageConfig)(qpqConfig, dynamicModuleLoader)),\n    ...(await getFileWriteObjectJsonActionProcessor(fileStorageConfig)(qpqConfig, dynamicModuleLoader)),\n    ...(await getFileReadBinaryContentsActionProcessor(fileStorageConfig)(qpqConfig, dynamicModuleLoader)),\n    ...(await getFileWriteBinaryContentsActionProcessor(fileStorageConfig)(qpqConfig, dynamicModuleLoader)),\n    ...(await getFileListDirectoryActionProcessor(fileStorageConfig)(qpqConfig, dynamicModuleLoader)),\n    ...(await getFileExistsActionProcessor(fileStorageConfig)(qpqConfig, dynamicModuleLoader)),\n    ...(await getFileDeleteActionProcessor(fileStorageConfig)(qpqConfig, dynamicModuleLoader)),\n    ...(await getFileGenerateTemporarySecureUrlActionProcessor(fileStorageConfig)(qpqConfig, dynamicModuleLoader)),\n    ...(await getFileGenerateTemporaryUploadSecureUrlActionProcessor(fileStorageConfig)(qpqConfig, dynamicModuleLoader)),\n    ...(await getFileIsColdStorageActionProcessor(fileStorageConfig)(qpqConfig, dynamicModuleLoader)),\n    ...(await getFileStreamOpenActionProcessor(fileStorageConfig)(qpqConfig, dynamicModuleLoader)),\n  });\n};\n\nexport * from './secureUrlUtils';\nexport * from './utils';\n"]}

package/lib/esm/dynamicActionProcessor/file/secureUrlUtils.js

@@ -37,3 +37,4 @@ export const verifySecureUrlToken = (tokenString, secret) => {
 export const getSecureUrlBaseUrl = (config) => {
     return `http://${config.secureUrlHost}:${config.secureUrlPort}`;
 };
+//# sourceMappingURL=secureUrlUtils.js.map

package/lib/esm/dynamicActionProcessor/file/secureUrlUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"secureUrlUtils.js","sourceRoot":"","sources":["../../../../src/dynamicActionProcessor/file/secureUrlUtils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AAWjC,wCAAwC;AACxC,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,KAAqB,EAAE,MAAc,EAAU,EAAE;IACpF,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IACtC,MAAM,aAAa,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;IAEjE,wBAAwB;IACxB,MAAM,SAAS,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;IAEhG,oCAAoC;IACpC,OAAO,GAAG,aAAa,IAAI,SAAS,EAAE,CAAC;AACzC,CAAC,CAAC;AAEF,mCAAmC;AACnC,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,WAAmB,EAAE,MAAc,EAAyB,EAAE;IACjG,IAAI,CAAC;QACH,MAAM,CAAC,aAAa,EAAE,SAAS,CAAC,GAAG,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAE1D,IAAI,CAAC,aAAa,IAAI,CAAC,SAAS,EAAE,CAAC;YACjC,OAAO,IAAI,CAAC;QACd,CAAC;QAED,mBAAmB;QACnB,MAAM,iBAAiB,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;QAExG,IAAI,SAAS,KAAK,iBAAiB,EAAE,CAAC;YACpC,OAAO,IAAI,CAAC;QACd,CAAC;QAED,iBAAiB;QACjB,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC,QAAQ,EAAE,CAAC;QACnE,MAAM,KAAK,GAAmB,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAElD,mBAAmB;QACnB,IAAI,KAAK,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC;YACjC,OAAO,IAAI,CAAC;QACd,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC,CAAC;AAEF,8BAA8B;AAC9B,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,MAAyB,EAAU,EAAE;IACvE,OAAO,UAAU,MAAM,CAAC,aAAa,IAAI,MAAM,CAAC,aAAa,EAAE,CAAC;AAClE,CAAC,CAAC","sourcesContent":["import * as crypto from 'crypto';\n\nimport { FileStorageConfig } from './types';\n\nexport interface SecureUrlToken {\n  fullFilepath: string;\n  operation: 'download' | 'upload';\n  expiresAt: number;\n  contentType?: string;\n}\n\n// Create a signed token for secure URLs\nexport const createSecureUrlToken = (token: SecureUrlToken, secret: string): string => {\n  const payload = JSON.stringify(token);\n  const payloadBase64 = Buffer.from(payload).toString('base64url');\n\n  // Create HMAC signature\n  const signature = crypto.createHmac('sha256', secret).update(payloadBase64).digest('base64url');\n\n  // Return token as payload.signature\n  return `${payloadBase64}.${signature}`;\n};\n\n// Verify and decode a signed token\nexport const verifySecureUrlToken = (tokenString: string, secret: string): SecureUrlToken | null => {\n  try {\n    const [payloadBase64, signature] = tokenString.split('.');\n\n    if (!payloadBase64 || !signature) {\n      return null;\n    }\n\n    // Verify signature\n    const expectedSignature = crypto.createHmac('sha256', secret).update(payloadBase64).digest('base64url');\n\n    if (signature !== expectedSignature) {\n      return null;\n    }\n\n    // Decode payload\n    const payload = Buffer.from(payloadBase64, 'base64url').toString();\n    const token: SecureUrlToken = JSON.parse(payload);\n\n    // Check expiration\n    if (token.expiresAt < Date.now()) {\n      return null;\n    }\n\n    return token;\n  } catch (error) {\n    return null;\n  }\n};\n\n// Get the secure URL base URL\nexport const getSecureUrlBaseUrl = (config: FileStorageConfig): string => {\n  return `http://${config.secureUrlHost}:${config.secureUrlPort}`;\n};\n"]}

package/lib/esm/dynamicActionProcessor/file/types.js

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=types.js.map

package/lib/esm/dynamicActionProcessor/file/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/dynamicActionProcessor/file/types.ts"],"names":[],"mappings":"","sourcesContent":["// Required config with all fields filled by the dev server\nexport interface FileStorageConfig {\n  storagePath: string;\n  secureUrlPort: number;\n  secureUrlHost: string;\n  secureUrlSecret: string;\n}\n"]}

package/lib/esm/dynamicActionProcessor/file/utils.js

@@ -47,3 +47,4 @@ export const ensureParentDirectoryExists = async (filePath) => {
     const parentDir = path.dirname(filePath);
     await ensureDirectoryExists(parentDir);
 };
+//# sourceMappingURL=utils.js.map

package/lib/esm/dynamicActionProcessor/file/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../src/dynamicActionProcessor/file/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE1D,OAAO,KAAK,EAAE,MAAM,aAAa,CAAC;AAClC,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAI7B,4CAA4C;AAC5C,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,KAAa,EAAE,SAAoB,EAAW,EAAE;IACtF,MAAM,YAAY,GAAG,YAAY,CAAC,gBAAgB,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,YAAY,KAAK,KAAK,CAAC,CAAC;IAEpG,IAAI,CAAC,YAAY,EAAE,CAAC;QAClB,OAAO,KAAK,CAAC;IACf,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC,CAAC;AAEF,iFAAiF;AACjF,8EAA8E;AAC9E,6EAA6E;AAC7E,MAAM,UAAU,uBAAuB,CAAC,KAAa,EAAE,SAAoB;IACzE,MAAM,YAAY,GAAG,YAAY,CAAC,qBAAqB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;IAC1E,OAAO,YAAY,EAAE,KAAK,EAAE,MAAM,IAAI,YAAY,CAAC,wBAAwB,CAAC,SAAS,CAAC,CAAC;AACzF,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,iBAAoC,EAAE,SAAoB,EAAE,KAAa,EAAE,QAAgB;IACzH,MAAM,OAAO,GAAG,uBAAuB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;IAC1D,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,iBAAiB,CAAC,WAAW,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;IAEzE,+CAA+C;IAC/C,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC9B,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC;IACrD,CAAC;IAED,uEAAuE;IACvE,IAAI,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QAC5B,MAAM,IAAI,KAAK,CAAC,eAAe,CAAC,CAAC;IACnC,CAAC;IAED,kDAAkD;IAClD,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;IAEzC,2BAA2B;IAC3B,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IAE3C,kCAAkC;IAClC,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IACxC,IAAI,GAAG,KAAK,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;QACnE,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;AAC5D,CAAC;AAED,4BAA4B;AAC5B,MAAM,CAAC,MAAM,qBAAqB,GAAG,KAAK,EAAE,OAAe,EAAiB,EAAE;IAC5E,MAAM,EAAE,CAAC,KAAK,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;AAC/C,CAAC,CAAC;AAEF,+CAA+C;AAC/C,MAAM,CAAC,MAAM,2BAA2B,GAAG,KAAK,EAAE,QAAgB,EAAiB,EAAE;IACnF,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IACzC,MAAM,qBAAqB,CAAC,SAAS,CAAC,CAAC;AACzC,CAAC,CAAC","sourcesContent":["import { QPQConfig, qpqCoreUtils } from 'quidproquo-core';\n\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\n\nimport { FileStorageConfig } from './types';\n\n// Resolve a drive name to a filesystem path\nexport const isStorageDriveNameValid = (drive: string, qpqConfig: QPQConfig): boolean => {\n  const storageDrive = qpqCoreUtils.getStorageDrives(qpqConfig).find((d) => d.storageDrive === drive);\n\n  if (!storageDrive) {\n    return false;\n  }\n\n  return true;\n};\n\n// Resolve the service that owns a drive's on-disk location. Drives declared with\n// `owner.module` are shared across services, so every caller reads and writes\n// under the owner's folder — mirroring how AWS resolves the bucket by owner.\nexport function resolveDriveServiceName(drive: string, qpqConfig: QPQConfig): string {\n  const storageDrive = qpqCoreUtils.getStorageDriveByName(drive, qpqConfig);\n  return storageDrive?.owner?.module ?? qpqCoreUtils.getApplicationModuleName(qpqConfig);\n}\n\nexport function resolveFilePath(fileStorageConfig: FileStorageConfig, qpqConfig: QPQConfig, drive: string, filepath: string): string {\n  const service = resolveDriveServiceName(drive, qpqConfig);\n  const root = path.resolve(fileStorageConfig.storagePath, service, drive);\n\n  // Block absolute paths and null bytes outright\n  if (path.isAbsolute(filepath)) {\n    throw new Error('Absolute paths are not allowed.');\n  }\n\n  // Check for null to prevent directory traversal attacks in native libs\n  if (filepath.includes('\\0')) {\n    throw new Error('Invalid path.');\n  }\n\n  // Normalize user input (collapses ., .., slashes)\n  const cleaned = path.normalize(filepath);\n\n  // Resolve against the root\n  const target = path.resolve(root, cleaned);\n\n  // Ensure target stays within root\n  const rel = path.relative(root, target);\n  if (rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel))) {\n    return target;\n  }\n\n  throw new Error('Invalid file path: escapes drive root.');\n}\n\n// Ensure a directory exists\nexport const ensureDirectoryExists = async (dirPath: string): Promise<void> => {\n  await fs.mkdir(dirPath, { recursive: true });\n};\n\n// Ensure the parent directory of a file exists\nexport const ensureParentDirectoryExists = async (filePath: string): Promise<void> => {\n  const parentDir = path.dirname(filePath);\n  await ensureDirectoryExists(parentDir);\n};\n"]}

package/lib/esm/dynamicActionProcessor/index.js

@@ -1 +1,2 @@
 export * from './file';
+//# sourceMappingURL=index.js.map

package/lib/esm/dynamicActionProcessor/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/dynamicActionProcessor/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC","sourcesContent":["export * from './file';\n"]}

package/lib/esm/index.d.ts

@@ -1,2 +1,3 @@
 export * from './actionProcessor';
 export * from './dynamicActionProcessor';
+export * from './traceStoryExecution';

package/lib/esm/index.js

@@ -1,2 +1,4 @@
 export * from './actionProcessor';
 export * from './dynamicActionProcessor';
+export * from './traceStoryExecution';
+//# sourceMappingURL=index.js.map

package/lib/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC;AACzC,cAAc,uBAAuB,CAAC","sourcesContent":["export * from './actionProcessor';\nexport * from './dynamicActionProcessor';\nexport * from './traceStoryExecution';\n"]}

package/lib/esm/traceStoryExecution/controllerWorker.d.ts

@@ -0,0 +1,11 @@
+export interface TraceControllerWorkerData {
+    scriptPatterns: string[];
+    onlyOwnCode: boolean;
+    maxSteps: number;
+    maxTraceMs: number;
+    maxValueLength: number;
+    maxProperties: number;
+    maxValueDepth: number;
+    maxSerializedLength: number;
+}
+export declare function traceControllerWorkerMain(): void;

package/lib/esm/traceStoryExecution/controllerWorker.js

@@ -0,0 +1,406 @@
+// The debug controller — runs on a WORKER THREAD and drives the V8 inspector against
+// the MAIN thread, which is executing the story replay (see traceStoryExecution).
+//
+// Strategy (chosen by the phase-0 spike, see trace-replay-plan.md): set a breakpoint on
+// every statement position of the traced scripts up front (getPossibleBreakpoints), then
+// plain resume between hits. This survives the yield -> await -> reader.next() chain of
+// the replay loop regardless of async task boundaries, and wastes no pauses on node
+// internals (unlike blackbox + stepInto).
+//
+// SHIPPING CONSTRAINT: lambdas are single-file webpack bundles, so this can't be loaded
+// as a worker FILE — traceStoryExecution serializes this function with
+// Function.prototype.toString() and runs it via new Worker(source, { eval: true }).
+// It must therefore be fully self-contained:
+//   - builtin require()s only, nothing captured from module scope
+//   - no syntax tsc would downlevel with module-scope helpers under the ES6 target:
+//     no async/await (__awaiter), no generators (__generator), no object spread (__assign)
+//
+// Protocol with the parent (traceStoryExecution):
+//   worker -> parent: { type: 'ready', tracedScriptUrls }   breakpoints armed, start the replay
+//                     { type: 'trace', steps, scripts, stats }   reply to 'done'
+//                     { type: 'filterLocations', requestId, scriptUrl, locations }   onlyOwnCode: map these through the source map
+//                     { type: 'fatal', error }
+//   parent -> worker: { type: 'done' }   replay finished, send the trace
+//                     { type: 'filteredLocations', requestId, locations }   reply to 'filterLocations'
+//
+// The story function is located via globalThis.__qpqTraceStoryFunction (set by the
+// parent before spawning): Runtime.evaluate -> [[FunctionLocation]] -> scriptId. Extra
+// scripts (other bundle chunks, dynamically loaded ones) are matched by scriptPatterns.
+export function traceControllerWorkerMain() {
+    // require, not import: this function body is the ENTIRE worker source (eval mode) —
+    // imports at module scope wouldn't exist when it runs. And eval('require'), not a
+    // bare require: bundlers rewrite require() calls at build time (webpack lambda builds
+    // turn them into __webpack_require__, which doesn't exist when this string is eval'd
+    // in the worker) — eval is opaque to them, so the worker's REAL cjs require survives.
+    const dynamicRequire = eval('require');
+    const inspector = dynamicRequire('node:inspector');
+    const workerThreads = dynamicRequire('node:worker_threads');
+    const parentPort = workerThreads.parentPort;
+    const options = workerThreads.workerData;
+    const session = new inspector.Session();
+    session.connectToMainThread();
+    const post = (method, params) => new Promise((resolve, reject) => session.post(method, params || {}, (error, result) => error ? reject(new Error(method + ': ' + error.message)) : resolve(result)));
+    const fatal = (error) => {
+        parentPort.postMessage({ type: 'fatal', error: String((error && error.stack) || error) });
+    };
+    const scriptPatterns = options.scriptPatterns.map((pattern) => new RegExp(pattern));
+    const scriptUrlsById = new Map();
+    const instrumentedScriptIds = new Set();
+    // The directory of the story function's own script (set during init). Bundles are
+    // chunk-SPLIT: a story exported through a factory wrapper (export const x = wrap(story))
+    // has its function object created in the FACTORY's chunk, while the code it runs lives
+    // in sibling chunks — so every script in the same directory is traced too. This covers
+    // any bundle layout (federated /tmp cache, lambda shell, dev-server dist) without
+    // needing an environment-specific pattern.
+    let storyScriptDirUrl = '';
+    // CJS require() scripts get plain-path urls, ESM imports get file:// urls — the same
+    // directory can appear both ways in one process, so compare scheme-stripped.
+    const normalizeScriptUrl = (url) => url.replace(/^file:\/\//, '').replace(/\\/g, '/');
+    const isTraceTargetUrl = (url) => !!url && (scriptPatterns.some((pattern) => pattern.test(url)) || (!!storyScriptDirUrl && normalizeScriptUrl(url).startsWith(storyScriptDirUrl)));
+    const steps = [];
+    let pauses = 0;
+    let breakpoints = 0;
+    let truncated = false;
+    let localsCaptureMs = 0;
+    let instrumentMs = 0;
+    let firstPauseAt = 0;
+    let ready = false;
+    // ── Value summarization ─────────────────────────────────────────────────────
+    // RemoteObject -> short display string. Depth comes from generatePreview (one level);
+    // the caps keep pathological values from exploding the trace.
+    const clampText = (text) => (text.length > options.maxValueLength ? text.slice(0, options.maxValueLength) + '…' : text);
+    const summarizeValue = (remoteObject) => {
+        if (!remoteObject)
+            return 'undefined';
+        if (remoteObject.type === 'undefined')
+            return 'undefined';
+        if (remoteObject.subtype === 'null')
+            return 'null';
+        if (remoteObject.unserializableValue)
+            return remoteObject.unserializableValue;
+        if (remoteObject.type === 'string' || remoteObject.type === 'number' || remoteObject.type === 'boolean') {
+            return clampText(JSON.stringify(remoteObject.value));
+        }
+        if (remoteObject.preview) {
+            const parts = [];
+            const previewProperties = remoteObject.preview.properties || [];
+            for (let i = 0; i < previewProperties.length && i < options.maxProperties; i += 1) {
+                const property = previewProperties[i];
+                const value = property.type === 'string' ? "'" + property.value + "'" : property.value;
+                parts.push(remoteObject.preview.subtype === 'array' ? value : property.name + ': ' + value);
+            }
+            const overflow = remoteObject.preview.overflow || previewProperties.length > options.maxProperties ? ', …' : '';
+            const body = parts.join(', ') + overflow;
+            return clampText(remoteObject.preview.subtype === 'array' ? '[' + body + ']' : '{' + body + '}');
+        }
+        return clampText(remoteObject.description || remoteObject.type);
+    };
+    // ── Deep serialization ──────────────────────────────────────────────────────
+    // Runs IN THE DEBUGGEE (Runtime.callFunctionOn with `this` = the value) at the pause,
+    // returning a JSON string of the value walked to the caps — what powers expandable
+    // object inspection in the viewer. Property reads are try/catch'd (getters can throw);
+    // circular refs and overflow become «...» placeholder strings. Same serialization
+    // constraints as this whole file: no async/generators/spread (it ships via toString).
+    function qpqSerializeValue(maxDepth, maxString, maxProps, maxTotal) {
+        const seen = [];
+        const walk = (value, depth) => {
+            if (value === null || typeof value === 'number' || typeof value === 'boolean')
+                return value;
+            if (typeof value === 'string')
+                return value.length > maxString ? value.slice(0, maxString) + '…' : value;
+            if (typeof value === 'undefined')
+                return '«undefined»';
+            if (typeof value === 'function')
+                return '«function ' + (value.name || '') + '»';
+            if (typeof value === 'bigint')
+                return value.toString() + 'n';
+            if (typeof value === 'symbol')
+                return value.toString();
+            if (value instanceof Date)
+                return value.toISOString();
+            if (value instanceof Error)
+                return '«' + (value.name || 'Error') + ': ' + value.message + '»';
+            if (value instanceof Map)
+                return '«Map(' + value.size + ')»';
+            if (value instanceof Set)
+                return '«Set(' + value.size + ')»';
+            if (depth >= maxDepth)
+                return Array.isArray(value) ? '«array[' + value.length + ']»' : '«object»';
+            if (seen.indexOf(value) >= 0)
+                return '«circular»';
+            seen.push(value);
+            let result;
+            if (Array.isArray(value)) {
+                result = [];
+                for (let i = 0; i < value.length && i < maxProps; i += 1) {
+                    try {
+                        result.push(walk(value[i], depth + 1));
+                    }
+                    catch (error) {
+                        result.push('«threw»');
+                    }
+                }
+                if (value.length > maxProps)
+                    result.push('«+' + (value.length - maxProps) + ' more»');
+            }
+            else {
+                result = {};
+                const keys = Object.keys(value);
+                for (let i = 0; i < keys.length && i < maxProps; i += 1) {
+                    try {
+                        result[keys[i]] = walk(value[keys[i]], depth + 1);
+                    }
+                    catch (error) {
+                        result[keys[i]] = '«threw»';
+                    }
+                }
+                if (keys.length > maxProps)
+                    result['«more»'] = '+' + (keys.length - maxProps) + ' properties';
+            }
+            seen.pop();
+            return result;
+        };
+        try {
+            const json = JSON.stringify(walk(this, 0));
+            return json && json.length <= maxTotal ? json : null;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    const isDeepSerializable = (remoteObject) => !!remoteObject && remoteObject.type === 'object' && remoteObject.subtype !== 'null' && !!remoteObject.objectId;
+    // ── Value capture ───────────────────────────────────────────────────────────
+    // Every value gets a short preview; object values also get a deep JSON serialization
+    // (in the debuggee, see qpqSerializeValue). Never fails — a value that can't be
+    // serialized keeps its preview.
+    const captureRemoteValue = (remoteObject) => {
+        const captured = { preview: summarizeValue(remoteObject) };
+        if (!isDeepSerializable(remoteObject)) {
+            return { captured, work: Promise.resolve() };
+        }
+        const work = post('Runtime.callFunctionOn', {
+            objectId: remoteObject.objectId,
+            functionDeclaration: qpqSerializeValue.toString(),
+            arguments: [
+                { value: options.maxValueDepth },
+                { value: options.maxValueLength },
+                { value: options.maxProperties },
+                { value: options.maxSerializedLength },
+            ],
+            returnByValue: true,
+        }).then((result) => {
+            if (result && result.result && typeof result.result.value === 'string') {
+                captured.json = result.result.value;
+            }
+        }, () => undefined);
+        return { captured, work };
+    };
+    // Local + block scopes only, outermost first so inner scopes win name collisions.
+    // At a return break position the frame also carries the value being returned.
+    const captureStepValues = (frame) => {
+        const startedAt = Date.now();
+        const values = { locals: {} };
+        const scopes = frame.scopeChain
+            .filter((scope) => (scope.type === 'local' || scope.type === 'block') && scope.object && scope.object.objectId)
+            .reverse();
+        let chain = Promise.resolve();
+        scopes.forEach((scope) => {
+            chain = chain
+                .then(() => post('Runtime.getProperties', { objectId: scope.object.objectId, ownProperties: true, generatePreview: true }))
+                .then((response) => {
+                let valueChain = Promise.resolve();
+                (response.result || []).forEach((property) => {
+                    const capture = captureRemoteValue(property.value);
+                    values.locals[property.name] = capture.captured;
+                    valueChain = valueChain.then(() => capture.work);
+                });
+                return valueChain;
+            });
+        });
+        if (frame.returnValue) {
+            const returnCapture = captureRemoteValue(frame.returnValue);
+            values.returnValue = returnCapture.captured;
+            chain = chain.then(() => returnCapture.work);
+        }
+        return chain.then(() => {
+            localsCaptureMs += Date.now() - startedAt;
+            return values;
+        });
+    };
+    // ── Script instrumentation ──────────────────────────────────────────────────
+    // onlyOwnCode: the parent (traceStoryExecution) filters candidate locations through
+    // the script's source map — only positions originating in the service's own code
+    // (not node_modules) get breakpoints. Round-tripped over parentPort because this
+    // worker can't load the source-map library (see the shipping constraint above).
+    let filterRequestSeq = 0;
+    const pendingFilterRequests = new Map();
+    const filterLocationsViaParent = (scriptId, locations) => {
+        if (!options.onlyOwnCode || locations.length === 0)
+            return Promise.resolve(locations);
+        filterRequestSeq += 1;
+        const requestId = filterRequestSeq;
+        return new Promise((resolve) => {
+            pendingFilterRequests.set(requestId, resolve);
+            parentPort.postMessage({ type: 'filterLocations', requestId, scriptUrl: scriptUrlsById.get(scriptId) || '', locations });
+        });
+    };
+    // getPossibleBreakpoints CAPS its response (~1000 locations) when the range is large —
+    // on a real bundle chunk (tens of thousands of lines) a single call covers only the
+    // top of the file and everything below it silently gets no breakpoints. Page through
+    // the script, restarting just past the last returned location, until a page comes back
+    // empty or stops advancing.
+    const getAllPossibleBreakpoints = (scriptId) => {
+        const allLocations = [];
+        const readPage = (startLine, startColumn) => post('Debugger.getPossibleBreakpoints', { start: { scriptId, lineNumber: startLine, columnNumber: startColumn } }).then((response) => {
+            const locations = response.locations || [];
+            if (locations.length === 0)
+                return allLocations;
+            locations.forEach((location) => allLocations.push(location));
+            const last = locations[locations.length - 1];
+            const nextLine = last.lineNumber;
+            const nextColumn = (last.columnNumber || 0) + 1;
+            if (nextLine < startLine || (nextLine === startLine && nextColumn <= startColumn))
+                return allLocations;
+            return readPage(nextLine, nextColumn);
+        });
+        return readPage(0, 0);
+    };
+    const instrumentScript = (scriptId) => {
+        if (instrumentedScriptIds.has(scriptId))
+            return Promise.resolve();
+        instrumentedScriptIds.add(scriptId);
+        return getAllPossibleBreakpoints(scriptId)
+            .then((locations) => filterLocationsViaParent(scriptId, locations))
+            .then((locations) => {
+            // PIPELINED, not chained: a service's chunks can hold tens of thousands of
+            // statement positions, and awaiting each setBreakpoint round-trip serially made
+            // instrumentation the dominant setup cost (it blew the ready timeout on real
+            // services). The session queues the posts; the backend processes them in order.
+            // Per-location failures are tolerated: nearby candidate positions can RESOLVE to
+            // the same actual breakpoint ("already exists") — one lost position must not
+            // abort the whole trace.
+            return Promise.all(locations.map((location) => post('Debugger.setBreakpoint', { location }).then(() => {
+                breakpoints += 1;
+            }, () => undefined))).then(() => undefined);
+        });
+    };
+    session.on('Debugger.scriptParsed', (message) => {
+        const url = message.params.url || '';
+        scriptUrlsById.set(message.params.scriptId, url);
+        // A traced bundle chunk loaded mid-story (async-node chunk loading) — instrument it
+        // as it appears so its statements are traced too.
+        if (ready && isTraceTargetUrl(url)) {
+            instrumentScript(message.params.scriptId).catch(fatal);
+        }
+    });
+    // ── Pause loop ──────────────────────────────────────────────────────────────
+    const onPaused = (message) => {
+        pauses += 1;
+        if (!firstPauseAt)
+            firstPauseAt = Date.now();
+        const frame = message.params.callFrames[0];
+        // Non-traced pause (e.g. the debugger; statement in qpqExecuteLog) — just resume.
+        if (!instrumentedScriptIds.has(frame.location.scriptId)) {
+            return post('Debugger.resume');
+        }
+        // Step budget AND wall-clock budget: locals capture costs several CDP round trips
+        // per step, so a big story can take MINUTES against maxSteps alone — long-running
+        // invocations stress their whole sandbox (a >5min trace exposed a 300s long-poll
+        // timeout bug in the qpq-log-extension, killing the lambda). Past either budget,
+        // stop pausing entirely so the replay finishes at full speed.
+        if (steps.length >= options.maxSteps || Date.now() - firstPauseAt > options.maxTraceMs) {
+            truncated = true;
+            return post('Debugger.setBreakpointsActive', { active: false }).then(() => post('Debugger.resume'));
+        }
+        return captureStepValues(frame)
+            .then((values) => {
+            const step = {
+                scriptId: frame.location.scriptId,
+                line: frame.location.lineNumber,
+                column: frame.location.columnNumber,
+                functionName: frame.functionName || '',
+                locals: values.locals,
+            };
+            if (values.returnValue) {
+                step.returnValue = values.returnValue;
+            }
+            steps.push(step);
+        })
+            .then(() => post('Debugger.resume'));
+    };
+    session.on('Debugger.paused', (message) => {
+        onPaused(message).catch(fatal);
+    });
+    // ── Parent protocol (also keeps the worker's event loop alive — an inspector
+    // session alone does not, the worker would silently exit) ────────────────────
+    parentPort.on('message', (message) => {
+        if (message && message.type === 'filteredLocations') {
+            const resolveFilter = pendingFilterRequests.get(message.requestId);
+            if (resolveFilter) {
+                pendingFilterRequests.delete(message.requestId);
+                resolveFilter(message.locations || []);
+            }
+            return;
+        }
+        if (message && message.type === 'done') {
+            const scripts = {};
+            scriptUrlsById.forEach((url, scriptId) => {
+                scripts[scriptId] = url;
+            });
+            const instrumentedScriptUrls = [];
+            instrumentedScriptIds.forEach((scriptId) => {
+                instrumentedScriptUrls.push(scriptUrlsById.get(scriptId) || scriptId);
+            });
+            parentPort.postMessage({
+                type: 'trace',
+                steps,
+                scripts,
+                stats: { pauses, breakpoints, localsCaptureMs, truncated, instrumentMs, instrumentedScriptUrls },
+            });
+        }
+    });
+    // ── Init: enable domains, find the story function's script, arm breakpoints ──
+    const initStartedAt = Date.now();
+    post('Runtime.enable')
+        .then(() => post('Debugger.enable'))
+        .then(() => post('Runtime.evaluate', { expression: 'globalThis.__qpqTraceStoryFunction' }))
+        .then((evaluation) => {
+        const objectId = evaluation && evaluation.result && evaluation.result.objectId;
+        if (!objectId)
+            return null;
+        return post('Runtime.getProperties', { objectId, ownProperties: true }).then((response) => {
+            const functionLocation = (response.internalProperties || []).find((property) => property.name === '[[FunctionLocation]]');
+            const location = functionLocation && functionLocation.value && functionLocation.value.value;
+            return location ? location.scriptId : null;
+        });
+    })
+        .then((storyFunctionScriptId) => {
+        const targetScriptIds = new Set();
+        if (storyFunctionScriptId) {
+            targetScriptIds.add(storyFunctionScriptId);
+            const storyScriptUrl = normalizeScriptUrl(scriptUrlsById.get(storyFunctionScriptId) || '');
+            storyScriptDirUrl = storyScriptUrl.slice(0, storyScriptUrl.lastIndexOf('/') + 1);
+        }
+        scriptUrlsById.forEach((url, scriptId) => {
+            if (isTraceTargetUrl(url))
+                targetScriptIds.add(scriptId);
+        });
+        if (targetScriptIds.size === 0) {
+            throw new Error('trace controller found no scripts to trace (no story function location, no scriptPatterns match)');
+        }
+        const instrumentations = [];
+        targetScriptIds.forEach((scriptId) => {
+            instrumentations.push(instrumentScript(scriptId));
+        });
+        return Promise.all(instrumentations).then(() => targetScriptIds);
+    })
+        .then((targetScriptIds) => {
+        ready = true;
+        instrumentMs = Date.now() - initStartedAt;
+        const tracedScriptUrls = [];
+        targetScriptIds.forEach((scriptId) => tracedScriptUrls.push(scriptUrlsById.get(scriptId) || scriptId));
+        parentPort.postMessage({ type: 'ready', tracedScriptUrls });
+    })
+        .catch(fatal);
+}
+//# sourceMappingURL=controllerWorker.js.map