velocious 1.0.571 → 1.0.573

package/build/src/deployment-api/sanitize.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Converts an integration-owned value (adapter report, live status, audit
+ * payload fragment) into a bounded JSON-safe structure: plain objects, arrays,
+ * strings, finite numbers, booleans, and null survive; everything else
+ * (functions, class instances, undefined) is dropped. String values and object
+ * keys are redacted and capped in length; deterministic suffixes preserve every
+ * value when redacted keys collide.
+ * @param {?} value - Raw value from the integration.
+ * @param {string[]} secrets - Secret values to redact.
+ * @param {number} [depth] - Current recursion depth.
+ * @returns {?} - JSON-safe redacted value, or undefined when the value cannot be represented.
+ */
+export function sanitizeAdapterValue(value: unknown, secrets: string[], depth?: number): unknown;
+/**
+ * Builds the sanitized failure payload persisted for a failed run. The message
+ * is redacted; an integration-provided plain-object `error.recovery` (e.g.
+ * Rampway reporting restoration of the previous release) is included after
+ * sanitization.
+ * @param {?} error - Thrown error from the adapter.
+ * @param {string[]} secrets - Secret values to redact.
+ * @returns {{message: string, recovery: (? | undefined)}} - Sanitized failure payload.
+ */
+export function sanitizeErrorPayload(error: unknown, secrets: string[]): {
+    message: string;
+    recovery: (unknown | undefined);
+};
+//# sourceMappingURL=sanitize.d.ts.map

package/build/src/deployment-api/sanitize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../../src/deployment-api/sanitize.js"],"names":[],"mappings":"AA2BA;;;;;;;;;;;GAWG;AACH,4CALW,OAAC,WACD,MAAM,EAAE,UACR,MAAM,GACJ,OAAC,CA2Db;AAED;;;;;;;;GAQG;AACH,4CAJW,OAAC,WACD,MAAM,EAAE,GACN;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,CAAC,OAAC,GAAG,SAAS,CAAC,CAAA;CAAC,CAQxD"}

package/build/src/deployment-api/sanitize.js

@@ -0,0 +1,100 @@
+// @ts-check
+const MAX_STRING_LENGTH = 4000;
+const MAX_DEPTH = 20;
+const REDACTED = "[redacted]";
+/**
+ * Replaces every occurrence of each configured secret in a string so tokens
+ * never leak into persisted run state, audit payloads, or API responses.
+ * @param {string} value - Raw string.
+ * @param {string[]} secrets - Secret values to redact.
+ * @returns {string} - Redacted string.
+ */
+function redactString(value, secrets) {
+    let result = value;
+    for (const secret of secrets) {
+        if (secret.length > 0)
+            result = result.split(secret).join(REDACTED);
+    }
+    if (result.length > MAX_STRING_LENGTH) {
+        result = `${result.slice(0, MAX_STRING_LENGTH)}…`;
+    }
+    return result;
+}
+/**
+ * Converts an integration-owned value (adapter report, live status, audit
+ * payload fragment) into a bounded JSON-safe structure: plain objects, arrays,
+ * strings, finite numbers, booleans, and null survive; everything else
+ * (functions, class instances, undefined) is dropped. String values and object
+ * keys are redacted and capped in length; deterministic suffixes preserve every
+ * value when redacted keys collide.
+ * @param {?} value - Raw value from the integration.
+ * @param {string[]} secrets - Secret values to redact.
+ * @param {number} [depth] - Current recursion depth.
+ * @returns {?} - JSON-safe redacted value, or undefined when the value cannot be represented.
+ */
+export function sanitizeAdapterValue(value, secrets, depth = 0) {
+    if (value === null)
+        return null;
+    if (depth > MAX_DEPTH)
+        return undefined;
+    const valueType = typeof value;
+    if (valueType === "string")
+        return redactString(value, secrets);
+    if (valueType === "number")
+        return Number.isFinite(value) ? value : null;
+    if (valueType === "boolean")
+        return value;
+    if (Array.isArray(value)) {
+        /** @type {Array<?>} */
+        const result = [];
+        for (const entry of value) {
+            const sanitized = sanitizeAdapterValue(entry, secrets, depth + 1);
+            if (sanitized !== undefined)
+                result.push(sanitized);
+        }
+        return result;
+    }
+    if (valueType === "object") {
+        const prototype = Object.getPrototypeOf(value);
+        if (prototype !== Object.prototype && prototype !== null)
+            return undefined;
+        /** @type {Record<string, ?>} */
+        const result = {};
+        for (const [key, entry] of Object.entries(value)) {
+            const sanitized = sanitizeAdapterValue(entry, secrets, depth + 1);
+            if (sanitized === undefined)
+                continue;
+            const redactedKey = redactString(key, secrets);
+            let availableKey = redactedKey;
+            let collisionNumber = 2;
+            while (Object.hasOwn(result, availableKey)) {
+                availableKey = `${redactedKey}#${collisionNumber}`;
+                collisionNumber++;
+            }
+            Object.defineProperty(result, availableKey, {
+                configurable: true,
+                enumerable: true,
+                value: sanitized,
+                writable: true
+            });
+        }
+        return result;
+    }
+    return undefined;
+}
+/**
+ * Builds the sanitized failure payload persisted for a failed run. The message
+ * is redacted; an integration-provided plain-object `error.recovery` (e.g.
+ * Rampway reporting restoration of the previous release) is included after
+ * sanitization.
+ * @param {?} error - Thrown error from the adapter.
+ * @param {string[]} secrets - Secret values to redact.
+ * @returns {{message: string, recovery: (? | undefined)}} - Sanitized failure payload.
+ */
+export function sanitizeErrorPayload(error, secrets) {
+    const rawMessage = error instanceof Error ? error.message : String(error);
+    const rawRecovery = error instanceof Error ? /** @type {Record<string, ?>} */ (error).recovery : undefined;
+    const recovery = sanitizeAdapterValue(rawRecovery, secrets);
+    return { message: redactString(rawMessage, secrets), recovery };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sanitize.js","sourceRoot":"","sources":["../../../src/deployment-api/sanitize.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nconst MAX_STRING_LENGTH = 4000\nconst MAX_DEPTH = 20\nconst REDACTED = \"[redacted]\"\n\n/**\n * Replaces every occurrence of each configured secret in a string so tokens\n * never leak into persisted run state, audit payloads, or API responses.\n * @param {string} value - Raw string.\n * @param {string[]} secrets - Secret values to redact.\n * @returns {string} - Redacted string.\n */\nfunction redactString(value, secrets) {\n  let result = value\n\n  for (const secret of secrets) {\n    if (secret.length > 0) result = result.split(secret).join(REDACTED)\n  }\n\n  if (result.length > MAX_STRING_LENGTH) {\n    result = `${result.slice(0, MAX_STRING_LENGTH)}…`\n  }\n\n  return result\n}\n\n/**\n * Converts an integration-owned value (adapter report, live status, audit\n * payload fragment) into a bounded JSON-safe structure: plain objects, arrays,\n * strings, finite numbers, booleans, and null survive; everything else\n * (functions, class instances, undefined) is dropped. String values and object\n * keys are redacted and capped in length; deterministic suffixes preserve every\n * value when redacted keys collide.\n * @param {?} value - Raw value from the integration.\n * @param {string[]} secrets - Secret values to redact.\n * @param {number} [depth] - Current recursion depth.\n * @returns {?} - JSON-safe redacted value, or undefined when the value cannot be represented.\n */\nexport function sanitizeAdapterValue(value, secrets, depth = 0) {\n  if (value === null) return null\n  if (depth > MAX_DEPTH) return undefined\n\n  const valueType = typeof value\n\n  if (valueType === \"string\") return redactString(value, secrets)\n  if (valueType === \"number\") return Number.isFinite(value) ? value : null\n  if (valueType === \"boolean\") return value\n\n  if (Array.isArray(value)) {\n    /** @type {Array<?>} */\n    const result = []\n\n    for (const entry of value) {\n      const sanitized = sanitizeAdapterValue(entry, secrets, depth + 1)\n\n      if (sanitized !== undefined) result.push(sanitized)\n    }\n\n    return result\n  }\n\n  if (valueType === \"object\") {\n    const prototype = Object.getPrototypeOf(value)\n\n    if (prototype !== Object.prototype && prototype !== null) return undefined\n\n    /** @type {Record<string, ?>} */\n    const result = {}\n\n    for (const [key, entry] of Object.entries(value)) {\n      const sanitized = sanitizeAdapterValue(entry, secrets, depth + 1)\n\n      if (sanitized === undefined) continue\n\n      const redactedKey = redactString(key, secrets)\n      let availableKey = redactedKey\n      let collisionNumber = 2\n\n      while (Object.hasOwn(result, availableKey)) {\n        availableKey = `${redactedKey}#${collisionNumber}`\n        collisionNumber++\n      }\n\n      Object.defineProperty(result, availableKey, {\n        configurable: true,\n        enumerable: true,\n        value: sanitized,\n        writable: true\n      })\n    }\n\n    return result\n  }\n\n  return undefined\n}\n\n/**\n * Builds the sanitized failure payload persisted for a failed run. The message\n * is redacted; an integration-provided plain-object `error.recovery` (e.g.\n * Rampway reporting restoration of the previous release) is included after\n * sanitization.\n * @param {?} error - Thrown error from the adapter.\n * @param {string[]} secrets - Secret values to redact.\n * @returns {{message: string, recovery: (? | undefined)}} - Sanitized failure payload.\n */\nexport function sanitizeErrorPayload(error, secrets) {\n  const rawMessage = error instanceof Error ? error.message : String(error)\n  const rawRecovery = error instanceof Error ? /** @type {Record<string, ?>} */ (error).recovery : undefined\n  const recovery = sanitizeAdapterValue(rawRecovery, secrets)\n\n  return {message: redactString(rawMessage, secrets), recovery}\n}\n"]}

package/build/src/http-client/request.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"request.d.ts","sourceRoot":"","sources":["../../../src/http-client/request.js"],"names":[],"mappings":"AAIA;IACE;;;;;;;;OAQG;IACH,sDANG;QAAsB,IAAI;QACL,MAAM,EAAnB,MAAM;QACS,OAAO,EAAtB,MAAM,EAAE;QACK,IAAI,EAAjB,MAAM;QACO,OAAO,EAApB,MAAM;KAChB,EAOA;IALC,yBAAgB;IAChB,kBAAsB;IACtB,eAAoB;IACpB,aAAgB;IAChB,gBAAsB;IAGxB,mBAQC;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACJ,MAAM,CAclB;IAED;;;;;OAKG;IACH,gBAJW,MAAM,SACN,MAAM,GAAG,MAAM,GACb,IAAI,CAIhB;IAED;;;OAGG;IACH,WAFa,IAAI,CAMhB;IAED;;;;OAIG;IACH,iBAHW,CAAS,IAAM,EAAN,MAAM,KAAI,IAAI,GACrB,IAAI,CAkBhB;CACF;mBA3FkB,aAAa"}
+{"version":3,"file":"request.d.ts","sourceRoot":"","sources":["../../../src/http-client/request.js"],"names":[],"mappings":"AAIA;IACE;;;;;;;;OAQG;IACH,sDANG;QAAsB,IAAI;QACL,MAAM,EAAnB,MAAM;QACS,OAAO,EAAtB,MAAM,EAAE;QACK,IAAI,EAAjB,MAAM;QACO,OAAO,EAApB,MAAM;KAChB,EAOA;IALC,yBAAgB;IAChB,kBAAsB;IACtB,eAAoB;IACpB,aAAgB;IAChB,gBAAsB;IAGxB,mBAQC;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACJ,MAAM,CAclB;IAED;;;;;OAKG;IACH,gBAJW,MAAM,SACN,MAAM,GAAG,MAAM,GACb,IAAI,CAIhB;IAED;;;OAGG;IACH,WAFa,IAAI,CAQhB;IAED;;;;OAIG;IACH,iBAHW,CAAS,IAAM,EAAN,MAAM,KAAI,IAAI,GACrB,IAAI,CAkBhB;CACF;mBA7FkB,aAAa"}

package/build/src/http-client/request.js

@@ -54,7 +54,9 @@ export default class Request {
      */
     prepare() {
         if (this.body) {
-            this.addHeader("Content-Length", Buffer.from(this.body).byteLength);
+            // Buffer.byteLength computes the UTF-8 length of strings without copying and
+            // returns .byteLength unchanged for Buffer/Uint8Array bodies.
+            this.addHeader("Content-Length", Buffer.byteLength(this.body, "utf8"));
         }
     }
     /**
@@ -75,4 +77,4 @@ export default class Request {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/sync/signed-sync-envelope-replay-service.d.ts

@@ -0,0 +1,154 @@
+/**
+ * @typedef {import("./device-identity.js").SignedSyncMutation} SignedSyncMutation
+ * @typedef {import("./offline-grant.js").SignedOfflineGrant} SignedOfflineGrant
+ */
+/**
+ * Sync-envelope replay service that authenticates via backend-signed device
+ * certificates and signed offline grants instead of online session tokens.
+ *
+ * This is the generic Velocious primitive for long-offline and peer-forwarded
+ * mutations: the HTTP uploader may differ from the mutation actor, but replay
+ * authority is derived from the signed envelope and grant, not the uploader's
+ * session.
+ *
+ * Every mutation is validated against the current sync manifest (the same
+ * contract as the controller's sync replay endpoint): the model and operation
+ * must be enabled in the current manifest, the grant resource entry must be
+ * enabled and list the operation, and the grant policy hash must equal both the
+ * mutation policy hash and the current manifest policy hash. Routed resources
+ * are authorized through an actor/grant-scoped ability built by the configured
+ * `abilityFactory`; without one, routed signed replay fails closed.
+ */
+export default class SignedSyncEnvelopeReplayService extends SyncEnvelopeReplayService {
+    /**
+     * Creates a signed sync-envelope replay service.
+     * @param {object} args - Constructor arguments.
+     * @param {import("./device-identity.js").SyncJsonWebKey} args.backendPublicKey - Backend public key used to verify device certificates.
+     * @param {Array<import("./offline-grant.js").OfflineGrantSigningKey>} [args.offlineGrantSigningKeys] - Offline-grant verification keys.
+     * @param {(userId: string) => Promise<{id: () => string} | null>} [args.actorLookup] - Optional lookup from grant user id to an actor object with an `id()` method. Defaults to a wrapper around the grant user id.
+     * @param {(args: {actor: ?, configuration: import("../configuration.js").default | null, grant: import("./offline-grant.js").OfflineGrant}) => Promise<import("../authorization/ability.js").default | null> | import("../authorization/ability.js").default | null} [args.abilityFactory] - Builds the actor/grant-scoped ability used to authorize routed resources. Required for routed signed replay; without it every routed sync fails closed.
+     * @param {Record<string, ?>} [args.rest] - Remaining arguments forwarded to {@link SyncEnvelopeReplayService}.
+     */
+    constructor({ abilityFactory, backendPublicKey, offlineGrantSigningKeys, actorLookup, ...rest }: {
+        backendPublicKey: import("./device-identity.js").SyncJsonWebKey;
+        offlineGrantSigningKeys?: import("./offline-grant.js").OfflineGrantSigningKey[] | undefined;
+        actorLookup?: ((userId: string) => Promise<{
+            id: () => string;
+        } | null>) | undefined;
+        abilityFactory?: ((args: {
+            actor: unknown;
+            configuration: import("../configuration.js").default | null;
+            grant: import("./offline-grant.js").OfflineGrant;
+        }) => Promise<import("../authorization/ability.js").default | null> | import("../authorization/ability.js").default | null) | undefined;
+        rest?: Record<string, any> | undefined;
+    });
+    abilityFactory: ((args: {
+        actor: unknown;
+        configuration: import("../configuration.js").default | null;
+        grant: import("./offline-grant.js").OfflineGrant;
+    }) => Promise<import("../authorization/ability.js").default | null> | import("../authorization/ability.js").default | null) | null;
+    backendPublicKey: import("node:crypto").webcrypto.JsonWebKey;
+    offlineGrantSigningKeys: import("./offline-grant.js").OfflineGrantSigningKey[];
+    actorLookup: ((userId: string) => Promise<{
+        id: () => string;
+    } | null>) | null;
+    /**
+     * Verifies signed mutations and then runs the generic replay loop over the
+     * derived sync envelopes. Verified actor, grant, and derived syncs are kept
+     * in the request-local `requestState` object so concurrent replay calls on
+     * one service instance cannot cross their authentication state.
+     * @param {Record<string, ?>} params - Request params.
+     * @param {Record<string, ?>} [requestState] - Request-local state shared with the base replay hooks.
+     * @returns {Promise<{syncs: Array<Record<string, ?>>}>} Replay response.
+     */
+    replay(params: Record<string, unknown>, requestState?: Record<string, unknown>): Promise<{
+        syncs: Array<Record<string, unknown>>;
+    }>;
+    /**
+     * Returns the verified actor prepared during {@link SignedSyncEnvelopeReplayService#replay}.
+     * @param {Record<string, ?>} _params - Request params.
+     * @param {Record<string, ?>} requestState - Request-local state.
+     * @returns {Promise<{authenticated: true, actor: ?} | {authenticated: false, errorCode: string, errorMessage: string}>} Auth result.
+     */
+    authenticateReplay(_params: Record<string, unknown>, requestState: Record<string, unknown>): Promise<{
+        authenticated: true;
+        actor: unknown;
+    } | {
+        authenticated: false;
+        errorCode: string;
+        errorMessage: string;
+    }>;
+    /**
+     * Returns the sync envelopes derived from the verified signed mutations.
+     * @param {Record<string, ?>} _params - Request params.
+     * @param {Record<string, ?>} requestState - Request-local state.
+     * @returns {Array<Record<string, ?>>} Sync envelopes.
+     */
+    replaySyncs(_params: Record<string, unknown>, requestState: Record<string, unknown>): Array<Record<string, unknown>>;
+    /**
+     * Derives the routed-resource ability from the verified signed actor and
+     * grant through the configured `abilityFactory`. The constructor-wide
+     * uploader ability is never used for signed replay: without a factory (or a
+     * factory result) every routed sync fails closed with a client-safe error.
+     * @param {{actor: ?, context: Record<string, ?>}} args - Verified actor and replay context.
+     * @returns {Promise<{ability: import("../authorization/ability.js").default, abilityContext: Record<string, ?>}>} Scoped ability and resource context.
+     */
+    replayAbilityFor({ actor, context }: {
+        actor: unknown;
+        context: Record<string, unknown>;
+    }): Promise<{
+        ability: import("../authorization/ability.js").default;
+        abilityContext: Record<string, unknown>;
+    }>;
+    /**
+     * Verifies every signed mutation, its offline grant, and the actor/grant
+     * consistency, then transforms the envelopes into the sync format the base
+     * replay service understands.
+     * @param {Record<string, ?>} params - Request params.
+     * @returns {Promise<{actor: ?, grant: import("./offline-grant.js").OfflineGrant, syncs: Array<Record<string, ?>>}>} Verified actor, common grant, and derived syncs.
+     */
+    verifyAndTransformSignedReplay(params: Record<string, unknown>): Promise<{
+        actor: unknown;
+        grant: import("./offline-grant.js").OfflineGrant;
+        syncs: Array<Record<string, unknown>>;
+    }>;
+    /**
+     * Validates a mutation against the current sync manifest: the model and the
+     * operation must be enabled, and the mutation's policy hash must match the
+     * current manifest policy hash.
+     * @param {{mutation: import("./device-identity.js").SyncMutation, syncManifest: Record<string, import("../configuration-types.js").NormalizedFrontendModelResourceSyncConfiguration>}} args - Validation args.
+     * @returns {void} Throws a client-safe error when the current policy denies the mutation.
+     */
+    validateCurrentSyncPolicy({ mutation, syncManifest }: {
+        mutation: import("./device-identity.js").SyncMutation;
+        syncManifest: Record<string, import("../configuration-types.js").NormalizedFrontendModelResourceSyncConfiguration>;
+    }): void;
+    /**
+     * Validates the verified offline grant against the current sync policy, the
+     * same contract as the controller's sync replay endpoint: the grant resource
+     * entry must be a normalized manifest entry (enabled with an operations list
+     * and the current policy hash), it must list the mutation operation, and its
+     * policy hash must equal both the mutation and current manifest hashes.
+     * Legacy array/true grant-resource shortcuts are not the bootstrap contract
+     * and never authorize a mutation.
+     * @param {{mutation: import("./device-identity.js").SyncMutation, offlineGrant: import("./offline-grant.js").OfflineGrant, syncManifest: Record<string, import("../configuration-types.js").NormalizedFrontendModelResourceSyncConfiguration>}} args - Validation args.
+     * @returns {void} Throws a client-safe error when the grant does not authorize the mutation.
+     */
+    validateGrantAgainstSyncPolicy({ mutation, offlineGrant, syncManifest }: {
+        mutation: import("./device-identity.js").SyncMutation;
+        offlineGrant: import("./offline-grant.js").OfflineGrant;
+        syncManifest: Record<string, import("../configuration-types.js").NormalizedFrontendModelResourceSyncConfiguration>;
+    }): void;
+    /**
+     * Transforms a verified signed mutation into a generic sync envelope.
+     * @param {{mutation: import("./device-identity.js").SyncMutation}} args - Transform args.
+     * @returns {Record<string, ?>} Sync envelope.
+     */
+    syncFromSignedMutation({ mutation }: {
+        mutation: import("./device-identity.js").SyncMutation;
+    }): Record<string, unknown>;
+}
+export type SignedSyncMutation = import("./device-identity.js").SignedSyncMutation;
+export type SignedOfflineGrant = import("./offline-grant.js").SignedOfflineGrant;
+import SyncEnvelopeReplayService from "./sync-envelope-replay-service.js";
+//# sourceMappingURL=signed-sync-envelope-replay-service.d.ts.map

package/build/src/sync/signed-sync-envelope-replay-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signed-sync-envelope-replay-service.d.ts","sourceRoot":"","sources":["../../../src/sync/signed-sync-envelope-replay-service.js"],"names":[],"mappings":"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"}