@spacefast/common 0.0.2

package/dist/contracts/tags.js

@@ -0,0 +1,1050 @@
+import { z } from "zod";
+import { baseDiagnosticSchema, CursorPaginationSchema, cursorListQuerySchema, dataEnvelope, } from "./common.js";
+export const tagVersionStatusSchema = z.enum([
+    "draft",
+    "in_review",
+    "approved",
+    "publishing",
+    "published",
+    "abandoned",
+]);
+export const tagEnvironmentSchema = z.enum(["production", "preview", "development"]);
+export const tagConsentCategorySchema = z.enum([
+    "necessary",
+    "functional",
+    "analytics",
+    "marketing",
+    "personalization",
+]);
+export const TAG_PRIVACY_SIGNAL_CONSENT_CATEGORIES = [
+    "analytics",
+    "marketing",
+    "personalization",
+];
+export const TAG_CONSENT_CATEGORY_DEFINITIONS = [
+    {
+        id: "necessary",
+        label: "Necessary",
+        description: "Required for basic site delivery, security, or visitor-requested actions.",
+        defaultGranted: true,
+        required: true,
+        privacySignalDefaultDenied: false,
+    },
+    {
+        id: "functional",
+        label: "Functional",
+        description: "Supports optional site features such as chat, support, comments, or monitoring.",
+        defaultGranted: true,
+        required: false,
+        privacySignalDefaultDenied: false,
+    },
+    {
+        id: "analytics",
+        label: "Analytics",
+        description: "Measures visits, usage, performance, funnels, or product behavior.",
+        defaultGranted: true,
+        required: false,
+        privacySignalDefaultDenied: true,
+    },
+    {
+        id: "marketing",
+        label: "Marketing",
+        description: "Supports ads, retargeting, attribution, conversion measurement, or campaigns.",
+        defaultGranted: true,
+        required: false,
+        privacySignalDefaultDenied: true,
+    },
+    {
+        id: "personalization",
+        label: "Personalization",
+        description: "Adapts content, recommendations, or experiences based on visitor behavior.",
+        defaultGranted: true,
+        required: false,
+        privacySignalDefaultDenied: true,
+    },
+];
+export const TAG_CONSENT_CATEGORY_IDS = TAG_CONSENT_CATEGORY_DEFINITIONS.map((category) => category.id);
+export const DEFAULT_TAG_CONSENT_DEFAULTS = Object.fromEntries(TAG_CONSENT_CATEGORY_DEFINITIONS.map((category) => [category.id, category.defaultGranted]));
+export const tagConsentPolicySchema = z.object({
+    version: z.literal(1).default(1),
+    categories: z.array(z.string().trim().min(1)).default(TAG_CONSENT_CATEGORY_IDS),
+    categoryDefinitions: z
+        .record(z.string(), z.object({
+        label: z.string(),
+        description: z.string(),
+        defaultGranted: z.boolean(),
+        required: z.boolean().default(false),
+        privacySignalDefaultDenied: z.boolean().default(false),
+    }))
+        .default(Object.fromEntries(TAG_CONSENT_CATEGORY_DEFINITIONS.map((category) => [
+        category.id,
+        {
+            label: category.label,
+            description: category.description,
+            defaultGranted: category.defaultGranted,
+            required: category.required,
+            privacySignalDefaultDenied: category.privacySignalDefaultDenied,
+        },
+    ]))),
+    defaultByCategory: z.record(z.string(), z.boolean()).default(DEFAULT_TAG_CONSENT_DEFAULTS),
+    regionDefaults: z.record(z.string(), z.record(z.string(), z.boolean())).default({}),
+    privacySignals: z
+        .object({
+        gpc: z.boolean().default(true),
+        dnt: z.boolean().default(true),
+        categories: z
+            .array(z.string().trim().min(1))
+            .default([...TAG_PRIVACY_SIGNAL_CONSENT_CATEGORIES]),
+    })
+        .default({
+        gpc: true,
+        dnt: true,
+        categories: [...TAG_PRIVACY_SIGNAL_CONSENT_CATEGORIES],
+    }),
+    tags: z.record(z.string(), z.array(z.string())).default({}),
+    diagnostics: z.array(baseDiagnosticSchema).default([]),
+});
+function isTagConsentPolicyRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+export function isKnownTagConsentCategory(value) {
+    return tagConsentCategorySchema.safeParse(value).success;
+}
+export function mergeTagConsentPolicyInputs(...policies) {
+    const merged = {};
+    for (const policy of policies) {
+        if (!isTagConsentPolicyRecord(policy))
+            continue;
+        for (const [key, value] of Object.entries(policy)) {
+            if (key !== "defaultByCategory" &&
+                key !== "regionDefaults" &&
+                key !== "privacySignals" &&
+                key !== "tags" &&
+                key !== "categories" &&
+                key !== "categoryDefinitions") {
+                merged[key] = value;
+            }
+        }
+        if (isTagConsentPolicyRecord(policy.categoryDefinitions)) {
+            const nextCategoryDefinitions = {
+                ...(isTagConsentPolicyRecord(merged.categoryDefinitions) ? merged.categoryDefinitions : {}),
+            };
+            for (const [category, definition] of Object.entries(policy.categoryDefinitions)) {
+                nextCategoryDefinitions[category] = {
+                    ...(isTagConsentPolicyRecord(nextCategoryDefinitions[category])
+                        ? nextCategoryDefinitions[category]
+                        : {}),
+                    ...(isTagConsentPolicyRecord(definition) ? definition : {}),
+                };
+            }
+            merged.categoryDefinitions = nextCategoryDefinitions;
+        }
+        if (isTagConsentPolicyRecord(policy.defaultByCategory)) {
+            merged.defaultByCategory = {
+                ...(isTagConsentPolicyRecord(merged.defaultByCategory) ? merged.defaultByCategory : {}),
+                ...policy.defaultByCategory,
+            };
+        }
+        if (isTagConsentPolicyRecord(policy.regionDefaults)) {
+            const nextRegionDefaults = {
+                ...(isTagConsentPolicyRecord(merged.regionDefaults) ? merged.regionDefaults : {}),
+            };
+            for (const [region, defaults] of Object.entries(policy.regionDefaults)) {
+                nextRegionDefaults[region] = {
+                    ...(isTagConsentPolicyRecord(nextRegionDefaults[region])
+                        ? nextRegionDefaults[region]
+                        : {}),
+                    ...(isTagConsentPolicyRecord(defaults) ? defaults : {}),
+                };
+            }
+            merged.regionDefaults = nextRegionDefaults;
+        }
+        if (isTagConsentPolicyRecord(policy.privacySignals)) {
+            merged.privacySignals = {
+                ...(isTagConsentPolicyRecord(merged.privacySignals) ? merged.privacySignals : {}),
+                ...policy.privacySignals,
+            };
+        }
+        if (isTagConsentPolicyRecord(policy.tags)) {
+            merged.tags = {
+                ...(isTagConsentPolicyRecord(merged.tags) ? merged.tags : {}),
+                ...policy.tags,
+            };
+        }
+        if (Array.isArray(policy.categories)) {
+            const categories = new Set(Array.isArray(merged.categories)
+                ? merged.categories.filter((item) => typeof item === "string")
+                : []);
+            for (const category of policy.categories) {
+                if (typeof category === "string")
+                    categories.add(category);
+            }
+            merged.categories = [...categories];
+        }
+    }
+    return Object.keys(merged).length > 0 ? merged : undefined;
+}
+export const tagGraphSchema = z
+    .object({
+    format: z.literal("spacefast.tag_graph.v1").default("spacefast.tag_graph.v1"),
+    tags: z.array(z.record(z.string(), z.unknown())).default([]),
+    triggers: z.array(z.record(z.string(), z.unknown())).default([]),
+    variables: z.array(z.record(z.string(), z.unknown())).default([]),
+    systemModules: z.record(z.string(), z.unknown()).default({}),
+    consentPolicy: z.record(z.string(), z.unknown()).optional(),
+})
+    .passthrough();
+export const emptyTagGraph = {
+    format: "spacefast.tag_graph.v1",
+    tags: [],
+    triggers: [],
+    variables: [],
+    systemModules: {},
+};
+export const tagValidationResultSchema = z.object({
+    valid: z.boolean(),
+    diagnostics: z.array(baseDiagnosticSchema),
+    requiredApprovals: z.array(z.string()),
+    graphRevision: z.number().int().positive(),
+});
+export const tagVersionSchema = z.object({
+    id: z.string(),
+    tagSetId: z.string(),
+    versionNumber: z.number().int().positive(),
+    baseVersionId: z.string().nullable(),
+    status: tagVersionStatusSchema,
+    title: z.string(),
+    description: z.string().nullable(),
+    graph: tagGraphSchema,
+    graphRevision: z.number().int().positive(),
+    validation: tagValidationResultSchema,
+    effectiveInputDigest: z.string().nullable(),
+    staticDigest: z.string().nullable(),
+    dynamicDigest: z.string().nullable(),
+    sdkRevision: z.string().nullable(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    publishedAt: z.string().nullable(),
+    immutableAt: z.string().nullable(),
+});
+export const tagVersionListQuerySchema = cursorListQuerySchema.extend({
+    status: tagVersionStatusSchema.optional(),
+});
+export const tagVersionListResponseSchema = z.object({
+    data: z.array(tagVersionSchema),
+    pagination: CursorPaginationSchema,
+});
+export const tagVersionResponseSchema = dataEnvelope(tagVersionSchema);
+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(),
+});
+export const tagVersionPatchSchema = z.object({
+    title: z.string().trim().min(1).max(255).optional(),
+    description: z.string().trim().max(4_000).nullable().optional(),
+});
+export const tagGraphResponseSchema = dataEnvelope(z.object({
+    versionId: z.string(),
+    graph: tagGraphSchema,
+    graphRevision: z.number().int().positive(),
+}));
+export const tagGraphPutSchema = z.object({
+    graph: tagGraphSchema,
+});
+export const tagGraphPatchSchema = z.object({
+    baseGraphRevision: z.number().int().positive(),
+    operations: z
+        .array(z.object({
+        op: z.enum(["replace"]),
+        path: z.enum(["graph"]),
+        value: tagGraphSchema,
+    }))
+        .length(1),
+});
+export const tagValidateResponseSchema = dataEnvelope(tagValidationResultSchema);
+export const tagDiffSchema = z.object({
+    baseVersionId: z.string().nullable(),
+    targetVersionId: z.string(),
+    addedTagIds: z.array(z.string()),
+    removedTagIds: z.array(z.string()),
+    changedTagIds: z.array(z.string()),
+    graphRevision: z.number().int().positive(),
+});
+export const tagDiffResponseSchema = dataEnvelope(tagDiffSchema);
+export const tagReleaseSchema = z.object({
+    id: z.string(),
+    tagSetId: z.string(),
+    environment: tagEnvironmentSchema,
+    versionId: z.string(),
+    previousVersionId: z.string().nullable(),
+    sdkRevision: z.string(),
+    staticDigest: z.string(),
+    releaseNotes: z.string().nullable(),
+    releasedAt: z.string(),
+});
+export const tagReleaseListResponseSchema = dataEnvelope(z.array(tagReleaseSchema));
+export const tagReleaseResponseSchema = dataEnvelope(tagReleaseSchema.extend({
+    artifact: z
+        .object({
+        id: z.string(),
+        revision: z.string(),
+        status: z.enum(["compiling", "ready", "failed", "superseded"]),
+    })
+        .nullable(),
+}));
+export const tagInheritanceSchema = z.object({
+    spaceId: z.string(),
+    teamId: z.string().nullable(),
+    inherited: z.boolean(),
+    teamTagSetId: z.string().nullable(),
+    overrides: z.array(z.object({
+        tagId: z.string(),
+        disabled: z.boolean().default(false),
+        reason: z.string().nullable().default(null),
+    })),
+});
+export const tagInheritanceResponseSchema = dataEnvelope(tagInheritanceSchema);
+export const tagInheritancePatchSchema = z.object({
+    inherited: z.boolean().optional(),
+    overrides: z
+        .array(z.object({
+        tagId: z.string().trim().min(1),
+        disabled: z.boolean().default(false),
+        reason: z.string().trim().max(500).nullable().optional(),
+    }))
+        .optional(),
+});
+export const tagActivityEventSchema = z.object({
+    id: z.string(),
+    type: z.string(),
+    versionId: z.string().nullable(),
+    environment: tagEnvironmentSchema.nullable(),
+    message: z.string(),
+    actor: z.record(z.string(), z.unknown()).nullable(),
+    createdAt: z.string(),
+});
+export const tagActivityResponseSchema = dataEnvelope(z.array(tagActivityEventSchema));
+export const tagEffectiveTagResponseSchema = dataEnvelope(z.object({
+    tag: z.record(z.string(), z.unknown()),
+    environment: tagEnvironmentSchema,
+    source: z.enum(["system", "team", "space", "unknown"]),
+}));
+export const tagReleasePutSchema = z.object({
+    versionId: z.string().trim().min(1),
+    expectedCurrentVersionId: z.string().trim().min(1).nullable().optional(),
+    releaseNotes: z.string().trim().max(4_000).nullable().optional(),
+});
+export const tagApplySchema = z.object({
+    config: z.unknown(),
+    title: z.string().trim().min(1).max(255).optional(),
+    description: z.string().trim().max(4_000).nullable().optional(),
+    submit: z.boolean().default(false),
+    releaseEnvironment: tagEnvironmentSchema.optional(),
+    expectedCurrentVersionId: z.string().trim().min(1).nullable().optional(),
+});
+export const tagApplyResponseSchema = dataEnvelope(z.object({
+    version: tagVersionSchema,
+    validation: tagValidationResultSchema,
+    release: tagReleaseSchema
+        .extend({
+        artifact: z
+            .object({
+            id: z.string(),
+            revision: z.string(),
+            status: z.enum(["compiling", "ready", "failed", "superseded"]),
+        })
+            .nullable(),
+    })
+        .nullable(),
+}));
+export const tagPreviewSessionSchema = z.object({
+    id: z.string(),
+    versionId: z.string(),
+    environment: tagEnvironmentSchema,
+    previewUrl: z.string(),
+    sdkRevision: z.string(),
+    cacheMode: z.literal("public, max-age=0, s-maxage=60, must-revalidate"),
+    websocket: z.object({ enabled: z.boolean() }),
+    createdAt: z.string(),
+    expiresAt: z.string(),
+    revokedAt: z.string().nullable(),
+});
+export const tagPreviewSessionResponseSchema = dataEnvelope(tagPreviewSessionSchema);
+export const tagPreviewSessionCreateSchema = z.object({
+    url: z.string().url().optional(),
+    ttlSeconds: z.number().int().min(60).max(86_400).default(3_600),
+    environment: tagEnvironmentSchema.default("production"),
+});
+export const tagDebugSessionCreateSchema = tagPreviewSessionCreateSchema;
+export const tagTriggerPresetSchema = z.enum([
+    "page_view",
+    "outbound_click",
+    "form_submit",
+    "file_download",
+    "scroll_depth",
+]);
+export const TAG_TRIGGER_PRESETS = [
+    {
+        id: "page_view",
+        triggerId: "preset.page_view",
+        name: "Page view",
+        description: "Runs when the page is ready.",
+    },
+    {
+        id: "outbound_click",
+        triggerId: "preset.outbound_click",
+        name: "Outbound click",
+        description: "Runs when a visitor clicks a link to another site.",
+    },
+    {
+        id: "form_submit",
+        triggerId: "preset.form_submit",
+        name: "Form submit",
+        description: "Runs when a visitor submits a form.",
+    },
+    {
+        id: "file_download",
+        triggerId: "preset.file_download",
+        name: "File download",
+        description: "Runs when a visitor clicks a downloadable file link.",
+    },
+    {
+        id: "scroll_depth",
+        triggerId: "preset.scroll_depth",
+        name: "Scroll depth",
+        description: "Runs as visitors reach 25%, 50%, 75%, and 90% page depth.",
+    },
+];
+export const tagTemplateIdSchema = z.enum([
+    "google-analytics",
+    "google-tag-manager",
+    "meta-pixel",
+    "tiktok-pixel",
+    "linkedin-insight",
+    "posthog",
+    "plausible",
+    "amplitude",
+    "segment",
+    "sentry-browser",
+    "intercom",
+    "hubspot",
+    "crisp",
+    "custom-javascript",
+]);
+const tagTemplateFieldSchema = z.object({
+    key: z.string(),
+    label: z.string(),
+    kind: z.enum(["text", "url", "secret", "textarea", "boolean"]).default("text"),
+    required: z.boolean().default(false),
+    placeholder: z.string().optional(),
+    help: z.string().optional(),
+    defaultValue: z.union([z.string(), z.boolean()]).optional(),
+});
+export const tagTemplateDefinitionSchema = z.object({
+    id: tagTemplateIdSchema,
+    name: z.string(),
+    category: z.enum(["analytics", "advertising", "product", "support", "monitoring", "custom"]),
+    description: z.string(),
+    defaultTriggers: z.array(tagTriggerPresetSchema),
+    consentCategories: z.array(tagConsentCategorySchema),
+    fields: z.array(tagTemplateFieldSchema),
+    scriptHosts: z.array(z.string()).default([]),
+    advanced: z.boolean().default(false),
+});
+export const tagTemplateSelectionSchema = z.object({
+    templateId: tagTemplateIdSchema,
+    id: z.string().trim().min(1).max(160).optional(),
+    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(),
+    schedule: z
+        .object({
+        activeFrom: z.string().trim().min(1).optional(),
+        activeUntil: z.string().trim().min(1).optional(),
+    })
+        .optional(),
+});
+export const tagTemplateListResponseSchema = dataEnvelope(z.object({
+    templates: z.array(tagTemplateDefinitionSchema),
+    triggers: z.array(z.object({
+        id: tagTriggerPresetSchema,
+        triggerId: z.string(),
+        name: z.string(),
+        description: z.string(),
+    })),
+}));
+export const tagConsentPolicyResponseSchema = dataEnvelope(z.object({
+    environment: tagEnvironmentSchema,
+    versionId: z.string().nullable(),
+    graphRevision: z.number().int().nonnegative(),
+    policy: tagConsentPolicySchema,
+}));
+export const tagTemplateGraphSchema = z.object({
+    templates: z.array(tagTemplateSelectionSchema).default([]),
+    eventPresets: z.array(tagTriggerPresetSchema).default([]),
+    graph: tagGraphSchema.optional(),
+});
+const TAG_TEMPLATE_DEFINITION_INPUTS = [
+    {
+        id: "google-analytics",
+        name: "Google Analytics",
+        category: "analytics",
+        description: "Measure page views and events with GA4.",
+        defaultTriggers: ["page_view"],
+        consentCategories: ["analytics"],
+        scriptHosts: ["www.googletagmanager.com"],
+        fields: [
+            {
+                key: "measurementId",
+                label: "Measurement ID",
+                required: true,
+                placeholder: "G-XXXXXXXXXX",
+            },
+        ],
+        advanced: false,
+    },
+    {
+        id: "google-tag-manager",
+        name: "Google Tag Manager",
+        category: "analytics",
+        description: "Load a GTM web container.",
+        defaultTriggers: ["page_view"],
+        consentCategories: ["analytics", "marketing"],
+        scriptHosts: ["www.googletagmanager.com"],
+        fields: [
+            {
+                key: "containerId",
+                label: "Container ID",
+                required: true,
+                placeholder: "GTM-XXXXXXX",
+            },
+        ],
+        advanced: false,
+    },
+    {
+        id: "meta-pixel",
+        name: "Meta Pixel",
+        category: "advertising",
+        description: "Load Meta Pixel and send PageView plus selected events.",
+        defaultTriggers: ["page_view"],
+        consentCategories: ["marketing"],
+        scriptHosts: ["connect.facebook.net"],
+        fields: [{ key: "pixelId", label: "Pixel ID", required: true, placeholder: "1234567890" }],
+        advanced: false,
+    },
+    {
+        id: "tiktok-pixel",
+        name: "TikTok Pixel",
+        category: "advertising",
+        description: "Load TikTok Pixel and send selected events.",
+        defaultTriggers: ["page_view"],
+        consentCategories: ["marketing"],
+        scriptHosts: ["analytics.tiktok.com"],
+        fields: [{ key: "pixelId", label: "Pixel ID", required: true, placeholder: "C000000000" }],
+        advanced: false,
+    },
+    {
+        id: "linkedin-insight",
+        name: "LinkedIn Insight Tag",
+        category: "advertising",
+        description: "Install LinkedIn Insight for ads attribution.",
+        defaultTriggers: ["page_view"],
+        consentCategories: ["marketing"],
+        scriptHosts: ["snap.licdn.com"],
+        fields: [
+            { key: "partnerId", label: "Partner ID", required: true, placeholder: "123456" },
+            { key: "conversionId", label: "Conversion ID", required: false, placeholder: "Optional" },
+        ],
+        advanced: false,
+    },
+    {
+        id: "posthog",
+        name: "PostHog",
+        category: "product",
+        description: "Load PostHog product analytics.",
+        defaultTriggers: ["page_view"],
+        consentCategories: ["analytics"],
+        scriptHosts: ["us.i.posthog.com", "eu.i.posthog.com", "app.posthog.com"],
+        fields: [
+            { key: "apiKey", label: "Project API key", required: true, placeholder: "phc_..." },
+            {
+                key: "host",
+                label: "Host",
+                kind: "url",
+                required: false,
+                placeholder: "https://us.i.posthog.com",
+            },
+        ],
+        advanced: false,
+    },
+    {
+        id: "plausible",
+        name: "Plausible",
+        category: "analytics",
+        description: "Load Plausible analytics.",
+        defaultTriggers: ["page_view"],
+        consentCategories: ["analytics"],
+        scriptHosts: ["plausible.io"],
+        fields: [
+            { key: "domain", label: "Domain", required: true, placeholder: "example.com" },
+            {
+                key: "scriptUrl",
+                label: "Script URL",
+                kind: "url",
+                required: false,
+                placeholder: "https://plausible.io/js/script.js",
+            },
+        ],
+        advanced: false,
+    },
+    {
+        id: "amplitude",
+        name: "Amplitude",
+        category: "product",
+        description: "Load Amplitude Browser SDK from CDN.",
+        defaultTriggers: ["page_view"],
+        consentCategories: ["analytics"],
+        scriptHosts: ["cdn.amplitude.com"],
+        fields: [{ key: "apiKey", label: "API key", required: true, placeholder: "abcdef..." }],
+        advanced: false,
+    },
+    {
+        id: "segment",
+        name: "Segment",
+        category: "analytics",
+        description: "Load Segment Analytics.js.",
+        defaultTriggers: ["page_view"],
+        consentCategories: ["analytics", "marketing"],
+        scriptHosts: ["cdn.segment.com"],
+        fields: [{ key: "writeKey", label: "Write key", required: true, placeholder: "abc123" }],
+        advanced: false,
+    },
+    {
+        id: "sentry-browser",
+        name: "Sentry Browser",
+        category: "monitoring",
+        description: "Load Sentry browser monitoring from the Sentry CDN loader.",
+        defaultTriggers: ["page_view"],
+        consentCategories: ["functional"],
+        scriptHosts: ["js.sentry-cdn.com"],
+        fields: [{ key: "loaderKey", label: "Loader key", required: true, placeholder: "abcd1234" }],
+        advanced: true,
+    },
+    {
+        id: "intercom",
+        name: "Intercom",
+        category: "support",
+        description: "Load Intercom Messenger.",
+        defaultTriggers: ["page_view"],
+        consentCategories: ["functional"],
+        scriptHosts: ["widget.intercom.io"],
+        fields: [{ key: "appId", label: "App ID", required: true, placeholder: "abc123" }],
+        advanced: false,
+    },
+    {
+        id: "hubspot",
+        name: "HubSpot",
+        category: "support",
+        description: "Load HubSpot tracking code.",
+        defaultTriggers: ["page_view"],
+        consentCategories: ["marketing"],
+        scriptHosts: ["js.hs-scripts.com"],
+        fields: [{ key: "portalId", label: "Portal ID", required: true, placeholder: "123456" }],
+        advanced: false,
+    },
+    {
+        id: "crisp",
+        name: "Crisp",
+        category: "support",
+        description: "Load Crisp chat.",
+        defaultTriggers: ["page_view"],
+        consentCategories: ["functional"],
+        scriptHosts: ["client.crisp.chat"],
+        fields: [{ key: "websiteId", label: "Website ID", required: true, placeholder: "uuid" }],
+        advanced: false,
+    },
+    {
+        id: "custom-javascript",
+        name: "Custom JavaScript",
+        category: "custom",
+        description: "Run your own script with consent and trigger controls.",
+        defaultTriggers: ["page_view"],
+        consentCategories: ["functional"],
+        scriptHosts: [],
+        fields: [
+            { key: "name", label: "Name", required: false, placeholder: "Custom JavaScript" },
+            { key: "code", label: "JavaScript", kind: "textarea", required: true },
+        ],
+        advanced: true,
+    },
+];
+export const TAG_TEMPLATE_DEFINITIONS = TAG_TEMPLATE_DEFINITION_INPUTS.map((template) => tagTemplateDefinitionSchema.parse(template));
+const TEMPLATE_BY_ID = new Map(TAG_TEMPLATE_DEFINITIONS.map((template) => [template.id, template]));
+export function listTagTemplates() {
+    return {
+        templates: TAG_TEMPLATE_DEFINITIONS,
+        triggers: TAG_TRIGGER_PRESETS,
+    };
+}
+export function tagTemplateById(id) {
+    return TEMPLATE_BY_ID.get(id) ?? null;
+}
+function templateFieldValue(config, key) {
+    const value = config[key];
+    return typeof value === "string" ? value.trim() : "";
+}
+function safeTagIdPart(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 64);
+}
+function htmlScript(code) {
+    return /^\s*<script\b[^>]*>[\s\S]*<\/script>\s*$/i.test(code)
+        ? code
+        : `<script>\n${code}\n</script>`;
+}
+function eventNameExpression(templateName) {
+    return [
+        "(function(){",
+        "var sf=window.__spacefast||{};",
+        "var ev=sf.event||{};",
+        `return ev.type||${JSON.stringify(templateName)};`,
+        "})()",
+    ].join("");
+}
+function eventDetailExpression() {
+    return [
+        "(function(){",
+        "var sf=window.__spacefast||{};",
+        "var ev=sf.event||{};",
+        "return ev.detail||{};",
+        "})()",
+    ].join("");
+}
+function providerBootstrapHtml(templateId, config) {
+    switch (templateId) {
+        case "google-analytics": {
+            const measurementId = templateFieldValue(config, "measurementId").toUpperCase();
+            return {
+                src: `https://www.googletagmanager.com/gtag/js?id=${encodeURIComponent(measurementId)}`,
+                attributes: { async: true },
+                html: htmlScript([
+                    "window.dataLayer = window.dataLayer || [];",
+                    "function gtag(){dataLayer.push(arguments);}",
+                    "gtag('js', new Date());",
+                    `gtag('config', ${JSON.stringify(measurementId)});`,
+                ].join("\n")),
+            };
+        }
+        case "google-tag-manager": {
+            const containerId = templateFieldValue(config, "containerId").toUpperCase();
+            return {
+                html: htmlScript([
+                    "(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':",
+                    "new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],",
+                    "j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=",
+                    "'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);",
+                    `})(window,document,'script','dataLayer',${JSON.stringify(containerId)});`,
+                ].join("\n")),
+            };
+        }
+        case "meta-pixel": {
+            const pixelId = templateFieldValue(config, "pixelId");
+            return {
+                html: htmlScript([
+                    "!function(f,b,e,v,n,t,s){if(f.fbq)return;n=f.fbq=function(){n.callMethod?",
+                    "n.callMethod.apply(n,arguments):n.queue.push(arguments)};if(!f._fbq)f._fbq=n;",
+                    "n.push=n;n.loaded=!0;n.version='2.0';n.queue=[];t=b.createElement(e);t.async=!0;",
+                    "t.src=v;s=b.getElementsByTagName(e)[0];s.parentNode.insertBefore(t,s)}",
+                    "(window,document,'script','https://connect.facebook.net/en_US/fbevents.js');",
+                    `fbq('init', ${JSON.stringify(pixelId)});`,
+                    "fbq('track', 'PageView');",
+                ].join("\n")),
+            };
+        }
+        case "tiktok-pixel": {
+            const pixelId = templateFieldValue(config, "pixelId");
+            return {
+                html: htmlScript([
+                    "!function (w, d, t) {",
+                    "w.TiktokAnalyticsObject=t;var ttq=w[t]=w[t]||[];ttq.methods=['page','track','identify','instances','debug','on','off','once','ready','alias','group','enableCookie','disableCookie'];",
+                    "ttq.setAndDefer=function(t,e){t[e]=function(){t.push([e].concat(Array.prototype.slice.call(arguments,0)))}};",
+                    "for(var i=0;i<ttq.methods.length;i++)ttq.setAndDefer(ttq,ttq.methods[i]);",
+                    "ttq.instance=function(t){var e=ttq._i[t]||[];for(var n=0;n<ttq.methods.length;n++)ttq.setAndDefer(e,ttq.methods[n]);return e};",
+                    "ttq.load=function(e,n){var i='https://analytics.tiktok.com/i18n/pixel/events.js';ttq._i=ttq._i||{};ttq._i[e]=[];ttq._i[e]._u=i;ttq._t=ttq._t||{};ttq._t[e]=+new Date;ttq._o=ttq._o||{};ttq._o[e]=n||{};var o=document.createElement('script');o.type='text/javascript';o.async=!0;o.src=i+'?sdkid='+e+'&lib='+t;var a=document.getElementsByTagName('script')[0];a.parentNode.insertBefore(o,a)};",
+                    `ttq.load(${JSON.stringify(pixelId)});ttq.page();`,
+                    "}(window, document, 'ttq');",
+                ].join("\n")),
+            };
+        }
+        case "linkedin-insight": {
+            const partnerId = templateFieldValue(config, "partnerId");
+            return {
+                html: htmlScript([
+                    "window._linkedin_partner_id = window._linkedin_partner_id || [];",
+                    `window._linkedin_partner_id.push(${JSON.stringify(partnerId)});`,
+                    "(function(l){if(!l){window.lintrk=function(a,b){window.lintrk.q.push([a,b])};window.lintrk.q=[]}",
+                    "var s=document.getElementsByTagName('script')[0];var b=document.createElement('script');",
+                    "b.type='text/javascript';b.async=true;b.src='https://snap.licdn.com/li.lms-analytics/insight.min.js';",
+                    "s.parentNode.insertBefore(b,s);})(window.lintrk);",
+                ].join("\n")),
+            };
+        }
+        case "posthog": {
+            const apiKey = templateFieldValue(config, "apiKey");
+            const host = templateFieldValue(config, "host") || "https://us.i.posthog.com";
+            return {
+                html: htmlScript([
+                    "!function(t,e){var o,n,p,r;e.__SV||(window.posthog=e,e._i=[],e.init=function(i,s,a){",
+                    "function g(t,e){var o=e.split('.');2==o.length&&(t=t[o[0]],e=o[1]);t[e]=function(){t.push([e].concat(Array.prototype.slice.call(arguments,0)))}}",
+                    "p=t.createElement('script');p.type='text/javascript';p.async=!0;p.src=s.api_host+'/static/array.js';",
+                    "r=t.getElementsByTagName('script')[0];r.parentNode.insertBefore(p,r);",
+                    "var u=e;void 0!==a?u=e[a]=[]:a='posthog';u.people=u.people||[];u.toString=function(t){var e='posthog';return'posthog'!==a&&(e+='.'+a),t||(e+=' (stub)'),e};",
+                    "u.people.toString=function(){return u.toString(1)+'.people (stub)'};o='capture identify alias people.set people.set_once set_config register register_once unregister opt_out_capturing has_opted_out_capturing opt_in_capturing reset isFeatureEnabled onFeatureFlags reloadFeatureFlags getFeatureFlag getFeatureFlagPayload group'.split(' ');",
+                    "for(n=0;n<o.length;n++)g(u,o[n]);e._i.push([i,s,a])},e.__SV=1)}(document,window.posthog||[]);",
+                    `posthog.init(${JSON.stringify(apiKey)}, { api_host: ${JSON.stringify(host)} });`,
+                ].join("\n")),
+            };
+        }
+        case "plausible": {
+            const domain = templateFieldValue(config, "domain");
+            const scriptUrl = templateFieldValue(config, "scriptUrl") || "https://plausible.io/js/script.js";
+            return { src: scriptUrl, attributes: { async: true, defer: true, "data-domain": domain } };
+        }
+        case "amplitude": {
+            const apiKey = templateFieldValue(config, "apiKey");
+            return {
+                src: "https://cdn.amplitude.com/libs/analytics-browser-2-min.js.gz",
+                attributes: { async: true },
+                html: htmlScript(`window.amplitude && amplitude.init(${JSON.stringify(apiKey)});`),
+                htmlAfterLoad: true,
+            };
+        }
+        case "segment": {
+            const writeKey = templateFieldValue(config, "writeKey");
+            return {
+                html: htmlScript([
+                    "!function(){var analytics=window.analytics=window.analytics||[];if(!analytics.initialize)",
+                    "if(analytics.invoked)window.console&&console.error&&console.error('Segment snippet included twice.');",
+                    "else{analytics.invoked=!0;analytics.methods=['trackSubmit','trackClick','trackLink','trackForm','pageview','identify','reset','group','track','ready','alias','debug','page','screen','once','off','on','addSourceMiddleware','addIntegrationMiddleware','setAnonymousId','addDestinationMiddleware','register'];",
+                    "analytics.factory=function(e){return function(){var t=Array.prototype.slice.call(arguments);t.unshift(e);analytics.push(t);return analytics}};",
+                    "for(var e=0;e<analytics.methods.length;e++){var key=analytics.methods[e];analytics[key]=analytics.factory(key)}",
+                    "analytics.load=function(key,e){var t=document.createElement('script');t.type='text/javascript';t.async=!0;t.src='https://cdn.segment.com/analytics.js/v1/'+key+'/analytics.min.js';var n=document.getElementsByTagName('script')[0];n.parentNode.insertBefore(t,n);analytics._loadOptions=e};",
+                    `analytics._writeKey=${JSON.stringify(writeKey)};analytics.SNIPPET_VERSION='5.2.0';analytics.load(${JSON.stringify(writeKey)});analytics.page();}}();`,
+                ].join("\n")),
+            };
+        }
+        case "sentry-browser": {
+            const loaderKey = templateFieldValue(config, "loaderKey");
+            return {
+                src: `https://js.sentry-cdn.com/${encodeURIComponent(loaderKey)}.min.js`,
+                attributes: { crossorigin: "anonymous" },
+            };
+        }
+        case "intercom": {
+            const appId = templateFieldValue(config, "appId");
+            return {
+                html: htmlScript([
+                    `window.intercomSettings = Object.assign({}, window.intercomSettings || {}, { app_id: ${JSON.stringify(appId)} });`,
+                    "(function(){var w=window;var ic=w.Intercom;if(typeof ic==='function'){ic('reattach_activator');ic('update',w.intercomSettings);}else{var d=document;var i=function(){i.c(arguments)};i.q=[];i.c=function(args){i.q.push(args)};w.Intercom=i;var l=function(){var s=d.createElement('script');s.type='text/javascript';s.async=true;s.src='https://widget.intercom.io/widget/'+w.intercomSettings.app_id;var x=d.getElementsByTagName('script')[0];x.parentNode.insertBefore(s,x);};if(document.readyState==='complete'){l();}else if(w.attachEvent){w.attachEvent('onload',l);}else{w.addEventListener('load',l,false);}}})();",
+                ].join("\n")),
+            };
+        }
+        case "hubspot": {
+            const portalId = templateFieldValue(config, "portalId");
+            return {
+                src: `https://js.hs-scripts.com/${encodeURIComponent(portalId)}.js`,
+                attributes: { async: true, defer: true, id: "hs-script-loader" },
+            };
+        }
+        case "crisp": {
+            const websiteId = templateFieldValue(config, "websiteId");
+            return {
+                html: htmlScript([
+                    "window.$crisp=[];",
+                    `window.CRISP_WEBSITE_ID=${JSON.stringify(websiteId)};`,
+                    "(function(){var d=document;var s=d.createElement('script');s.src='https://client.crisp.chat/l.js';s.async=1;d.getElementsByTagName('head')[0].appendChild(s);})();",
+                ].join("\n")),
+            };
+        }
+        case "custom-javascript":
+            return { html: htmlScript(templateFieldValue(config, "code")) };
+    }
+    const exhaustive = templateId;
+    return exhaustive;
+}
+function providerEventHtml(templateId, templateName, config) {
+    const nameExpr = eventNameExpression(templateName);
+    const detailExpr = eventDetailExpression();
+    switch (templateId) {
+        case "google-analytics":
+            return htmlScript(`window.gtag && gtag('event', ${nameExpr}, ${detailExpr});`);
+        case "google-tag-manager":
+            return htmlScript(`window.dataLayer && dataLayer.push(Object.assign({ event: ${nameExpr} }, ${detailExpr}));`);
+        case "meta-pixel":
+            return htmlScript(`window.fbq && fbq('trackCustom', ${nameExpr}, ${detailExpr});`);
+        case "tiktok-pixel":
+            return htmlScript(`window.ttq && ttq.track(${nameExpr}, ${detailExpr});`);
+        case "linkedin-insight": {
+            const conversionId = templateFieldValue(config, "conversionId");
+            return conversionId
+                ? htmlScript(`window.lintrk && lintrk('track', { conversion_id: ${JSON.stringify(conversionId)} });`)
+                : "";
+        }
+        case "posthog":
+            return htmlScript(`window.posthog && posthog.capture(${nameExpr}, ${detailExpr});`);
+        case "plausible":
+            return htmlScript(`window.plausible && plausible(${nameExpr}, { props: ${detailExpr} });`);
+        case "amplitude":
+            return htmlScript(`window.amplitude && amplitude.track && amplitude.track(${nameExpr}, ${detailExpr});`);
+        case "segment":
+            return htmlScript(`window.analytics && analytics.track && analytics.track(${nameExpr}, ${detailExpr});`);
+        case "intercom":
+            return htmlScript(`window.Intercom && Intercom('trackEvent', ${nameExpr}, ${detailExpr});`);
+        case "hubspot":
+            return htmlScript(`window._hsq=window._hsq||[];_hsq.push(['trackEvent', { id: ${nameExpr}, value: JSON.stringify(${detailExpr}) }]);`);
+        case "crisp":
+            return htmlScript(`window.$crisp && $crisp.push(['set', 'session:event', [[${nameExpr}, ${detailExpr}]]]);`);
+        case "sentry-browser":
+            return "";
+        case "custom-javascript":
+            return null;
+    }
+    return null;
+}
+function templatePrimaryValue(template, config) {
+    const field = template.fields.find((item) => item.required) ?? template.fields[0];
+    return field ? templateFieldValue(config, field.key) : "";
+}
+function validateTemplateSelection(selection) {
+    const template = tagTemplateById(selection.templateId);
+    if (!template) {
+        throw new Error(`Unknown tag template: ${selection.templateId}`);
+    }
+    for (const field of template.fields) {
+        if (field.required && !templateFieldValue(selection.config, field.key)) {
+            throw new Error(`${template.name} requires ${field.label}.`);
+        }
+    }
+    return template;
+}
+export function tagPresetTriggers(ids) {
+    const triggerIds = new Set(ids);
+    return TAG_TRIGGER_PRESETS.filter((preset) => triggerIds.has(preset.id)).map((preset) => ({
+        id: preset.triggerId,
+        type: preset.id,
+        source: "preset",
+    }));
+}
+export function tagGraphFromTemplateSelection(input) {
+    const selection = tagTemplateSelectionSchema.parse(input);
+    const template = validateTemplateSelection(selection);
+    const triggers = selection.triggers?.length ? selection.triggers : template.defaultTriggers;
+    const triggerIds = triggers
+        .map((trigger) => TAG_TRIGGER_PRESETS.find((preset) => preset.id === trigger)?.triggerId)
+        .filter((triggerId) => Boolean(triggerId));
+    const primary = templatePrimaryValue(template, selection.config);
+    const idBase = selection.id ?? `tag.${template.id}.${safeTagIdPart(primary || template.id)}`;
+    const consent = selection.consentCategories ?? template.consentCategories;
+    const common = {
+        source: "template",
+        templateId: template.id,
+        enabled: selection.enabled,
+        consent: { categories: consent },
+        environments: selection.environments,
+        schedule: selection.schedule,
+    };
+    const bootstrap = providerBootstrapHtml(template.id, selection.config);
+    const tags = [
+        {
+            ...common,
+            id: idBase,
+            name: selection.name ?? template.name,
+            triggerIds: template.id === "custom-javascript"
+                ? triggerIds
+                : triggerIds.length > 0
+                    ? [triggerIds[0]]
+                    : [],
+            once: template.id !== "custom-javascript",
+            ...bootstrap,
+        },
+    ];
+    for (const trigger of triggers.filter((item) => item !== "page_view")) {
+        const triggerId = TAG_TRIGGER_PRESETS.find((preset) => preset.id === trigger)?.triggerId;
+        const html = providerEventHtml(template.id, `${template.name} ${trigger.replace(/_/g, " ")}`, selection.config);
+        if (!triggerId || !html)
+            continue;
+        tags.push({
+            ...common,
+            id: `${idBase}.${trigger}`,
+            name: `${selection.name ?? template.name} ${trigger.replace(/_/g, " ")}`,
+            triggerIds: [triggerId],
+            dependsOnTagId: idBase,
+            html,
+        });
+    }
+    return {
+        ...emptyTagGraph,
+        tags,
+        triggers: tagPresetTriggers(triggers),
+    };
+}
+export function mergeTagGraphs(...graphs) {
+    const tagMap = new Map();
+    const triggerMap = new Map();
+    const variableMap = new Map();
+    const systemModules = {};
+    const consentPolicies = [];
+    for (const graph of graphs) {
+        if (!graph)
+            continue;
+        for (const tag of graph.tags ?? []) {
+            const id = typeof tag.id === "string" ? tag.id : JSON.stringify(tag);
+            tagMap.set(id, tag);
+        }
+        for (const trigger of graph.triggers ?? []) {
+            const id = typeof trigger.id === "string" ? trigger.id : JSON.stringify(trigger);
+            triggerMap.set(id, trigger);
+        }
+        for (const variable of graph.variables ?? []) {
+            const id = typeof variable.id === "string" ? variable.id : JSON.stringify(variable);
+            variableMap.set(id, variable);
+        }
+        Object.assign(systemModules, graph.systemModules ?? {});
+        const consentPolicy = graph.consentPolicy;
+        if (consentPolicy)
+            consentPolicies.push(consentPolicy);
+    }
+    const consentPolicy = mergeTagConsentPolicyInputs(...consentPolicies);
+    return {
+        format: "spacefast.tag_graph.v1",
+        tags: [...tagMap.values()],
+        triggers: [...triggerMap.values()],
+        variables: [...variableMap.values()],
+        systemModules,
+        ...(consentPolicy ? { consentPolicy } : {}),
+    };
+}
+export function tagGraphFromTemplateSelections(selections) {
+    return mergeTagGraphs(...selections.map((selection) => tagGraphFromTemplateSelection(selection)));
+}
+export const tagEffectiveResponseSchema = dataEnvelope(z.object({
+    tagSetId: z.string().nullable(),
+    environment: tagEnvironmentSchema,
+    versionId: z.string().nullable(),
+    graph: tagGraphSchema,
+    graphRevision: z.number().int().nonnegative(),
+    sdkRevision: z.string().nullable(),
+    sources: z.array(z.object({
+        type: z.enum(["team", "space", "system"]),
+        versionId: z.string().nullable(),
+    })),
+}));