@spacefast/common 0.0.10 → 0.0.12

package/dist/contracts/tags.js

@@ -184,6 +184,148 @@ export function mergeTagConsentPolicyInputs(...policies) {
     }
     return Object.keys(merged).length > 0 ? merged : undefined;
 }
+export const TAG_GRAPH_MAX_ENCODED_BYTES = 256 * 1024;
+export const TAG_GRAPH_MAX_REQUEST_BODY_BYTES = 512 * 1024;
+export const TAG_GRAPH_MAX_TAGS = 256;
+export const TAG_GRAPH_MAX_TRIGGERS = 256;
+export const TAG_GRAPH_MAX_VARIABLES = 256;
+export const TAG_GRAPH_MAX_SYSTEM_MODULES = 64;
+export const TAG_GRAPH_MAX_ARRAY_ITEMS = 256;
+export const TAG_GRAPH_MAX_OBJECT_KEYS = 64;
+export const TAG_GRAPH_MAX_STRING_BYTES = 64 * 1024;
+export const TAG_GRAPH_MAX_DEPTH = 16;
+const TAG_GRAPH_TEXT_ENCODER = new TextEncoder();
+function tagGraphStringBytes(value) {
+    return TAG_GRAPH_TEXT_ENCODER.encode(value).byteLength;
+}
+function refineTagGraphBudget(value, ctx) {
+    let encodedBytes = 0;
+    const addEncodedBytes = (bytes, path) => {
+        encodedBytes += bytes;
+        if (encodedBytes <= TAG_GRAPH_MAX_ENCODED_BYTES)
+            return true;
+        ctx.addIssue({
+            code: "custom",
+            message: `Tag graph must not exceed ${TAG_GRAPH_MAX_ENCODED_BYTES} encoded bytes.`,
+            path,
+        });
+        return false;
+    };
+    const pending = [
+        { value, path: [], depth: 0 },
+    ];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (!current)
+            break;
+        if (typeof current.value === "string") {
+            if (tagGraphStringBytes(current.value) > TAG_GRAPH_MAX_STRING_BYTES) {
+                ctx.addIssue({
+                    code: "custom",
+                    message: `Tag graph strings must not exceed ${TAG_GRAPH_MAX_STRING_BYTES} bytes.`,
+                    path: current.path,
+                });
+                return;
+            }
+            if (!addEncodedBytes(tagGraphStringBytes(JSON.stringify(current.value)), current.path)) {
+                return;
+            }
+            continue;
+        }
+        if (current.value === null) {
+            if (!addEncodedBytes(4, current.path))
+                return;
+            continue;
+        }
+        if (current.value === undefined) {
+            // Template expansion can retain optional object properties as undefined.
+            // JSON omits them from objects (and encodes them as null in arrays), so
+            // counting four bytes is a safe upper bound without rejecting the graph.
+            if (!addEncodedBytes(4, current.path))
+                return;
+            continue;
+        }
+        if (typeof current.value !== "object") {
+            let encoded;
+            try {
+                encoded = JSON.stringify(current.value);
+            }
+            catch {
+                encoded = undefined;
+            }
+            if (encoded === undefined) {
+                ctx.addIssue({
+                    code: "custom",
+                    message: "Tag graph values must be serializable as JSON.",
+                    path: current.path,
+                });
+                return;
+            }
+            if (!addEncodedBytes(tagGraphStringBytes(encoded), current.path))
+                return;
+            continue;
+        }
+        if (current.depth >= TAG_GRAPH_MAX_DEPTH) {
+            ctx.addIssue({
+                code: "custom",
+                message: `Tag graph values must not exceed ${TAG_GRAPH_MAX_DEPTH} levels.`,
+                path: current.path,
+            });
+            return;
+        }
+        if (Array.isArray(current.value)) {
+            if (current.value.length > TAG_GRAPH_MAX_ARRAY_ITEMS) {
+                ctx.addIssue({
+                    code: "custom",
+                    message: `Tag graph arrays must not exceed ${TAG_GRAPH_MAX_ARRAY_ITEMS} items.`,
+                    path: current.path,
+                });
+                return;
+            }
+            if (!addEncodedBytes(2 + Math.max(0, current.value.length - 1), current.path)) {
+                return;
+            }
+            for (const [index, item] of current.value.entries()) {
+                pending.push({ value: item, path: [...current.path, index], depth: current.depth + 1 });
+            }
+            continue;
+        }
+        const prototype = Object.getPrototypeOf(current.value);
+        if (prototype !== Object.prototype && prototype !== null) {
+            ctx.addIssue({
+                code: "custom",
+                message: "Tag graph values must be plain JSON objects.",
+                path: current.path,
+            });
+            return;
+        }
+        const entries = Object.entries(current.value);
+        if (entries.length > TAG_GRAPH_MAX_OBJECT_KEYS) {
+            ctx.addIssue({
+                code: "custom",
+                message: `Tag graph objects must not exceed ${TAG_GRAPH_MAX_OBJECT_KEYS} keys.`,
+                path: current.path,
+            });
+            return;
+        }
+        if (!addEncodedBytes(2 + Math.max(0, entries.length - 1), current.path))
+            return;
+        for (const [key, item] of entries) {
+            if (tagGraphStringBytes(key) > TAG_GRAPH_MAX_STRING_BYTES) {
+                ctx.addIssue({
+                    code: "custom",
+                    message: `Tag graph object keys must not exceed ${TAG_GRAPH_MAX_STRING_BYTES} bytes.`,
+                    path: [...current.path, key],
+                });
+                return;
+            }
+            if (!addEncodedBytes(tagGraphStringBytes(JSON.stringify(key)) + 1, [...current.path, key])) {
+                return;
+            }
+            pending.push({ value: item, path: [...current.path, key], depth: current.depth + 1 });
+        }
+    }
+}
 export const tagGraphSchema = z
     .object({
     format: z.literal("spacefast.tag_graph.v1").default("spacefast.tag_graph.v1"),
@@ -194,6 +336,28 @@ export const tagGraphSchema = z
     consentPolicy: z.record(z.string(), z.unknown()).optional(),
 })
     .passthrough();
+const tagGraphBudgetedShape = {
+    format: z.literal("spacefast.tag_graph.v1").default("spacefast.tag_graph.v1"),
+    tags: z.array(z.record(z.string(), z.unknown())).max(TAG_GRAPH_MAX_TAGS).default([]),
+    triggers: z.array(z.record(z.string(), z.unknown())).max(TAG_GRAPH_MAX_TRIGGERS).default([]),
+    variables: z.array(z.record(z.string(), z.unknown())).max(TAG_GRAPH_MAX_VARIABLES).default([]),
+    systemModules: z
+        .record(z.string(), z.unknown())
+        .refine((modules) => Object.keys(modules).length <= TAG_GRAPH_MAX_SYSTEM_MODULES, {
+        message: `Tag graph systemModules must not exceed ${TAG_GRAPH_MAX_SYSTEM_MODULES} entries.`,
+    })
+        .default({}),
+    consentPolicy: z.record(z.string(), z.unknown()).optional(),
+};
+export const tagGraphCloneSchema = z
+    .object(tagGraphBudgetedShape)
+    .passthrough()
+    .superRefine(refineTagGraphBudget);
+export const tagGraphWriteSchema = z
+    .object(tagGraphBudgetedShape)
+    .strict()
+    .superRefine(refineTagGraphBudget)
+    .describe(`Tag graph v1 write input. The server enforces a maximum of ${TAG_GRAPH_MAX_ENCODED_BYTES} encoded bytes, ${TAG_GRAPH_MAX_TAGS} tags, ${TAG_GRAPH_MAX_TRIGGERS} triggers, ${TAG_GRAPH_MAX_VARIABLES} variables, ${TAG_GRAPH_MAX_SYSTEM_MODULES} system modules, ${TAG_GRAPH_MAX_ARRAY_ITEMS} items per nested array, ${TAG_GRAPH_MAX_OBJECT_KEYS} keys per object, ${TAG_GRAPH_MAX_STRING_BYTES} encoded bytes per string, and ${TAG_GRAPH_MAX_DEPTH} nested levels. Unknown top-level fields are rejected.`);
 export const emptyTagGraph = {
     format: "spacefast.tag_graph.v1",
     tags: [],
@@ -239,7 +403,7 @@ export const tagVersionCreateSchema = z.object({
     title: z.string().trim().min(1).max(255).default("Draft tag version"),
     description: z.string().trim().max(4_000).nullable().optional(),
     baseVersionId: z.string().trim().min(1).nullable().optional(),
-    graph: tagGraphSchema.optional(),
+    graph: tagGraphWriteSchema.optional(),
 });
 export const tagVersionPatchSchema = z.object({
     title: z.string().trim().min(1).max(255).optional(),
@@ -251,7 +415,7 @@ export const tagGraphResponseSchema = dataEnvelope(z.object({
     graphRevision: z.number().int().positive(),
 }));
 export const tagGraphPutSchema = z.object({
-    graph: tagGraphSchema,
+    graph: tagGraphWriteSchema,
 });
 export const tagGraphPatchSchema = z.object({
     baseGraphRevision: z.number().int().positive(),
@@ -259,7 +423,7 @@ export const tagGraphPatchSchema = z.object({
         .array(z.object({
         op: z.enum(["replace"]),
         path: z.enum(["graph"]),
-        value: tagGraphSchema,
+        value: tagGraphWriteSchema,
     }))
         .length(1),
 });
@@ -378,13 +542,18 @@ export const tagPreviewSessionCreateSchema = z.object({
     environment: tagEnvironmentSchema.default("production"),
 });
 export const tagDebugSessionCreateSchema = tagPreviewSessionCreateSchema;
-export const tagTriggerPresetSchema = z.enum([
+const TAG_TRIGGER_PRESET_VALUES = [
     "page_view",
     "outbound_click",
     "form_submit",
     "file_download",
     "scroll_depth",
-]);
+];
+export const tagTriggerPresetSchema = z.enum(TAG_TRIGGER_PRESET_VALUES);
+export const TAG_TEMPLATE_MAX_SELECTIONS = TAG_GRAPH_MAX_TAGS;
+export const TAG_TEMPLATE_MAX_TRIGGERS = TAG_TRIGGER_PRESET_VALUES.length;
+export const TAG_TEMPLATE_MAX_CONSENT_CATEGORIES = tagConsentCategorySchema.options.length;
+export const TAG_TEMPLATE_MAX_ENVIRONMENTS = tagEnvironmentSchema.options.length;
 export const TAG_TRIGGER_PRESETS = [
     {
         id: "page_view",
@@ -459,9 +628,18 @@ export const tagTemplateSelectionSchema = z.object({
     name: z.string().trim().min(1).max(160).optional(),
     enabled: z.boolean().default(true),
     config: z.record(z.string(), z.unknown()).default({}),
-    triggers: z.array(tagTriggerPresetSchema).optional(),
-    consentCategories: z.array(tagConsentCategorySchema).optional(),
-    environments: z.array(tagEnvironmentSchema).optional(),
+    triggers: z
+        .array(tagTriggerPresetSchema)
+        .max(TAG_TEMPLATE_MAX_TRIGGERS)
+        .refine((triggers) => new Set(triggers).size === triggers.length, {
+        message: "Tag template triggers must be unique.",
+    })
+        .optional(),
+    consentCategories: z
+        .array(tagConsentCategorySchema)
+        .max(TAG_TEMPLATE_MAX_CONSENT_CATEGORIES)
+        .optional(),
+    environments: z.array(tagEnvironmentSchema).max(TAG_TEMPLATE_MAX_ENVIRONMENTS).optional(),
     schedule: z
         .object({
         activeFrom: z.string().trim().min(1).optional(),
@@ -485,9 +663,15 @@ export const tagConsentPolicyResponseSchema = dataEnvelope(z.object({
     policy: tagConsentPolicySchema,
 }));
 export const tagTemplateGraphSchema = z.object({
-    templates: z.array(tagTemplateSelectionSchema).default([]),
-    eventPresets: z.array(tagTriggerPresetSchema).default([]),
-    graph: tagGraphSchema.optional(),
+    templates: z.array(tagTemplateSelectionSchema).max(TAG_TEMPLATE_MAX_SELECTIONS).default([]),
+    eventPresets: z
+        .array(tagTriggerPresetSchema)
+        .max(TAG_TEMPLATE_MAX_TRIGGERS)
+        .refine((presets) => new Set(presets).size === presets.length, {
+        message: "Tag event presets must be unique.",
+    })
+        .default([]),
+    graph: tagGraphWriteSchema.optional(),
 });
 const TAG_TEMPLATE_DEFINITION_INPUTS = [
     {

package/dist/contracts/transfers.d.ts

@@ -84,8 +84,8 @@ export declare const spaceTransferSchema: z.ZodObject<{
         code: z.ZodString;
         severity: z.ZodEnum<{
             info: "info";
-            warning: "warning";
             error: "error";
+            warning: "warning";
         }>;
         message: z.ZodString;
         path: z.ZodOptional<z.ZodNullable<z.ZodString>>;

package/dist/contracts/variables.d.ts

@@ -31,12 +31,12 @@ export declare const SystemVariableSchema: z.ZodObject<{
 export declare const variableUpsertSchema: z.ZodObject<{
     name: z.ZodString;
     value: z.ZodString;
-    secret: z.ZodOptional<z.ZodBoolean>;
+    secret: z.ZodBoolean;
     channelValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, z.core.$strip>;
 export declare const variableValueUpsertSchema: z.ZodObject<{
     value: z.ZodString;
-    secret: z.ZodOptional<z.ZodBoolean>;
+    secret: z.ZodBoolean;
     channelValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, z.core.$strip>;
 export declare const variableListQuerySchema: z.ZodObject<{
@@ -122,8 +122,8 @@ export declare const variableMutationResponseSchema: z.ZodObject<{
             code: z.ZodString;
             severity: z.ZodEnum<{
                 info: "info";
-                warning: "warning";
                 error: "error";
+                warning: "warning";
             }>;
             message: z.ZodString;
             path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -166,8 +166,8 @@ export declare const variableDeleteResponseSchema: z.ZodObject<{
             code: z.ZodString;
             severity: z.ZodEnum<{
                 info: "info";
-                warning: "warning";
                 error: "error";
+                warning: "warning";
             }>;
             message: z.ZodString;
             path: z.ZodOptional<z.ZodNullable<z.ZodString>>;

package/dist/contracts/variables.js

@@ -29,8 +29,9 @@ export const VariableSchema = z.object({
 });
 // Version provenance (internal-docs/platform.md "Variable rules"): versions
 // record which variable names and value hashes they were finalized with —
-// never values. Stored on the version row and echoed on the Version resource;
-// the cascade discovers affected spaces through it.
+// never values. Stored only for internal cascade and synchronization; it is
+// never echoed on the public Version resource because historical rows cannot
+// distinguish sealed-value hashes safely.
 export const variableProvenanceSchema = z
     .array(z.object({
     name: z.string().describe("Variable name the version was finalized with."),
@@ -49,7 +50,7 @@ export const SystemVariableSchema = z.object({
 export const variableUpsertSchema = z.object({
     name: variableNameSchema,
     value: z.string().min(1),
-    secret: z.boolean().optional().describe("Mark the value write-only. Defaults to false."),
+    secret: z.boolean().describe("Whether the value is write-only."),
     channelValues: z.record(z.string(), z.string()).optional(),
 });
 export const variableValueUpsertSchema = variableUpsertSchema.omit({ name: true });

package/dist/contracts/webhooks.d.ts

@@ -94,8 +94,8 @@ export declare const webhookDeliverySchema: z.ZodObject<{
         code: z.ZodString;
         severity: z.ZodEnum<{
             info: "info";
-            warning: "warning";
             error: "error";
+            warning: "warning";
         }>;
         message: z.ZodString;
         path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -135,8 +135,8 @@ export declare const webhookDeliveryListResponseSchema: z.ZodObject<{
             code: z.ZodString;
             severity: z.ZodEnum<{
                 info: "info";
-                warning: "warning";
                 error: "error";
+                warning: "warning";
             }>;
             message: z.ZodString;
             path: z.ZodOptional<z.ZodNullable<z.ZodString>>;