@dbx-tools/shared-generator 0.0.0-stage → 0.9.136

package/lib/src/workflow.js

@@ -0,0 +1,240 @@
+/**
+ * Browser-safe contracts for generated Databricks demo assets.
+ *
+ * @module
+ */
+import { z } from "zod";
+import { BrandPackageSchema } from "./brand.js";
+import { KpiResearchResultSchema, ResearchedKpiSchema } from "./kpi.js";
+const nonBlankString = z.string().trim().min(1);
+const identifier = z.string().regex(/^[a-z][a-z0-9_]*$/, "Expected a lowercase SQL identifier.");
+/** Presentation created after generated data is validated. */
+export const PresentationModeSchema = z.enum(["dashboard", "genie"]);
+/** Complete input for the governed generator workflow. */
+export const GeneratorRequestSchema = z
+    .object({
+    company: nonBlankString.max(200).describe("Company or brand represented by the demo."),
+    purpose: nonBlankString.max(200).describe("Short purpose used in schema and asset names."),
+    queries: z
+        .array(nonBlankString.max(500))
+        .min(1)
+        .max(10)
+        .describe("Business questions that shape KPI research and generated data."),
+    website: z
+        .string()
+        .url()
+        .optional()
+        .describe("Known company website for brand disambiguation."),
+    presentation: PresentationModeSchema.default("dashboard").describe("Dashboard with automatic companion Genie, or standalone Genie without a dashboard."),
+    rowCount: z
+        .number()
+        .int()
+        .min(1_000)
+        .max(100_000)
+        .default(50_000)
+        .describe("Rows generated in the primary fact table."),
+})
+    .strict()
+    .describe("Request for a per-user Databricks demo data environment.");
+/** Supported deterministic column generators. */
+export const GeneratedColumnSchema = z.discriminatedUnion("generator", [
+    z
+        .object({
+        name: identifier.describe("Column name."),
+        generator: z.literal("id"),
+        description: nonBlankString.describe("Column business meaning."),
+    })
+        .strict(),
+    z
+        .object({
+        name: identifier.describe("Column name."),
+        generator: z.literal("date"),
+        description: nonBlankString.describe("Column business meaning."),
+        days: z.number().int().min(30).max(1_095).describe("Generated history window in days."),
+    })
+        .strict(),
+    z
+        .object({
+        name: identifier.describe("Column name."),
+        generator: z.literal("category"),
+        description: nonBlankString.describe("Column business meaning."),
+        values: z.array(nonBlankString.max(80)).min(2).max(12).describe("Skewed category values."),
+    })
+        .strict(),
+    z
+        .object({
+        name: identifier.describe("Column name."),
+        generator: z.literal("number"),
+        description: nonBlankString.describe("Column business meaning."),
+        minimum: z.number().describe("Minimum generated value."),
+        maximum: z.number().describe("Maximum generated value."),
+        decimals: z.number().int().min(0).max(4).default(2).describe("Decimal precision."),
+    })
+        .strict(),
+    z
+        .object({
+        name: identifier.describe("Column name."),
+        generator: z.literal("boolean"),
+        description: nonBlankString.describe("Column business meaning."),
+        trueProbability: z.number().min(0.01).max(0.99).describe("Share of true rows."),
+    })
+        .strict(),
+]);
+/** KPI binding compiled into validation SQL and dashboard measures. */
+export const GeneratedMetricSchema = ResearchedKpiSchema.extend({
+    aggregation: z
+        .enum(["count", "sum", "average"])
+        .describe("Safe aggregate compiled by the generator."),
+    column: identifier.optional().describe("Numeric source column; omitted for count."),
+}).strict();
+/** Structured plan compiled into SQL and presentation assets. */
+export const GeneratorPlanSchema = z
+    .object({
+    table: identifier.describe("Primary generated Delta table name."),
+    rowCount: z.number().int().min(1_000).max(100_000).describe("Rows to generate."),
+    columns: z
+        .array(GeneratedColumnSchema)
+        .min(4)
+        .max(16)
+        .describe("Typed deterministic column generators."),
+    metrics: z.array(GeneratedMetricSchema).min(1).max(6).describe("Dashboard and Genie KPIs."),
+    story: nonBlankString.describe("Business anomaly and impact represented in the data."),
+    sampleQuestions: z
+        .array(nonBlankString.max(300))
+        .min(3)
+        .max(8)
+        .describe("Questions supported by the generated table."),
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    const names = new Set();
+    for (const [index, column] of value.columns.entries()) {
+        if (names.has(column.name)) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["columns", index, "name"],
+                message: "Generated column names must be unique.",
+            });
+        }
+        names.add(column.name);
+    }
+    if (!value.columns.some(({ generator }) => generator === "id")) {
+        ctx.addIssue({ code: "custom", path: ["columns"], message: "An id column is required." });
+    }
+    if (!value.columns.some(({ generator }) => generator === "date")) {
+        ctx.addIssue({ code: "custom", path: ["columns"], message: "A date column is required." });
+    }
+    if (!value.columns.some(({ generator }) => generator === "category")) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["columns"],
+            message: "A category column is required.",
+        });
+    }
+    const numeric = new Set(value.columns.filter(({ generator }) => generator === "number").map(({ name }) => name));
+    for (const [index, metric] of value.metrics.entries()) {
+        if (metric.aggregation !== "count" && (!metric.column || !numeric.has(metric.column))) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["metrics", index, "column"],
+                message: "Sum and average metrics require a generated numeric column.",
+            });
+        }
+    }
+})
+    .describe("Validated plan for deterministic synthetic data and analytics assets.");
+/** Input for the standalone structured data-planning tool. */
+export const PlanGeneratorDataRequestSchema = z
+    .object({
+    request: GeneratorRequestSchema,
+    brand: BrandPackageSchema,
+    kpiResearch: KpiResearchResultSchema,
+})
+    .strict()
+    .describe("Inputs needed to build a typed generator plan.");
+/** Location and trusted identity for one generated schema. */
+export const GeneratedSchemaSchema = z
+    .object({
+    catalog: identifier.describe("Configured Unity Catalog."),
+    schema: identifier.describe("Per-user generated schema."),
+    fullName: nonBlankString.describe("Quoted-safe catalog.schema display name."),
+    principal: nonBlankString.describe("Trusted OBO Databricks user name."),
+})
+    .strict()
+    .describe("Provisioned per-user Unity Catalog schema.");
+/** Input for per-user schema provisioning. */
+export const ProvisionGeneratorSchemaRequestSchema = z
+    .object({
+    request: GeneratorRequestSchema.pick({ company: true, purpose: true }),
+})
+    .strict()
+    .describe("Request to provision the active user's generated schema.");
+/** Input for generated data materialization. */
+export const MaterializeGeneratorDataRequestSchema = z
+    .object({
+    location: GeneratedSchemaSchema,
+    plan: GeneratorPlanSchema,
+})
+    .strict()
+    .describe("Request to materialize and validate generated Delta data.");
+/** Created tables and KPI validation statements. */
+export const MaterializedGeneratorDataSchema = z
+    .object({
+    tables: z.array(nonBlankString).min(1).describe("Created fully qualified Delta tables."),
+    validationStatements: z
+        .record(identifier, nonBlankString)
+        .describe("Statement IDs keyed by validated KPI name."),
+})
+    .strict()
+    .describe("Materialized and validated generated data.");
+/** Input shared by dashboard and standalone Genie creation tools. */
+export const CreateGeneratorPresentationRequestSchema = z
+    .object({
+    request: GeneratorRequestSchema.pick({
+        company: true,
+        purpose: true,
+    }),
+    location: GeneratedSchemaSchema,
+    plan: GeneratorPlanSchema,
+    brand: BrandPackageSchema,
+})
+    .strict()
+    .describe("Request to create a presentation asset over generated data.");
+/** Dashboard output with its automatic companion Genie Agent. */
+export const GeneratedDashboardSchema = z
+    .object({
+    dashboardId: nonBlankString.describe("Created Lakeview dashboard ID."),
+    path: nonBlankString.optional().describe("Workspace path, when returned."),
+    companionGenie: z.literal("AUTO").describe("Dashboard-published companion Genie mode."),
+})
+    .strict();
+/** Standalone Genie output used only when no dashboard is requested. */
+export const GeneratedGenieSpaceSchema = z
+    .object({
+    spaceId: nonBlankString.describe("Created standalone Genie space ID."),
+    title: nonBlankString.describe("Genie space title."),
+})
+    .strict();
+/** Terminal workflow output. */
+export const GeneratedAssetsSchema = z
+    .object({
+    request: GeneratorRequestSchema,
+    schema: GeneratedSchemaSchema,
+    tables: z.array(nonBlankString).min(1).describe("Created fully qualified Delta tables."),
+    brand: BrandPackageSchema,
+    kpiResearch: KpiResearchResultSchema,
+    plan: GeneratorPlanSchema,
+    dashboard: GeneratedDashboardSchema.optional(),
+    genie: GeneratedGenieSpaceSchema.optional(),
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    if ((value.dashboard === undefined) === (value.genie === undefined)) {
+        ctx.addIssue({
+            code: "custom",
+            message: "Exactly one dashboard or standalone Genie space is required.",
+        });
+    }
+})
+    .describe("Generated Databricks data and presentation assets.");
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workflow.js","sourceRoot":"","sources":["../../src/workflow.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Browser-safe contracts for generated Databricks demo assets.\n *\n * @module\n */\n\nimport { z } from \"zod\";\nimport { BrandPackageSchema } from \"./brand.ts\";\nimport { KpiResearchResultSchema, ResearchedKpiSchema } from \"./kpi.ts\";\n\nconst nonBlankString = z.string().trim().min(1);\nconst identifier = z.string().regex(/^[a-z][a-z0-9_]*$/, \"Expected a lowercase SQL identifier.\");\n\n/** Presentation created after generated data is validated. */\nexport const PresentationModeSchema = z.enum([\"dashboard\", \"genie\"]);\n\n/** Presentation mode. */\nexport type PresentationMode = z.infer<typeof PresentationModeSchema>;\n\n/** Complete input for the governed generator workflow. */\nexport const GeneratorRequestSchema = z\n  .object({\n    company: nonBlankString.max(200).describe(\"Company or brand represented by the demo.\"),\n    purpose: nonBlankString.max(200).describe(\"Short purpose used in schema and asset names.\"),\n    queries: z\n      .array(nonBlankString.max(500))\n      .min(1)\n      .max(10)\n      .describe(\"Business questions that shape KPI research and generated data.\"),\n    website: z\n      .string()\n      .url()\n      .optional()\n      .describe(\"Known company website for brand disambiguation.\"),\n    presentation: PresentationModeSchema.default(\"dashboard\").describe(\n      \"Dashboard with automatic companion Genie, or standalone Genie without a dashboard.\",\n    ),\n    rowCount: z\n      .number()\n      .int()\n      .min(1_000)\n      .max(100_000)\n      .default(50_000)\n      .describe(\"Rows generated in the primary fact table.\"),\n  })\n  .strict()\n  .describe(\"Request for a per-user Databricks demo data environment.\");\n\n/** Generator workflow input after defaults. */\nexport type GeneratorRequest = z.output<typeof GeneratorRequestSchema>;\n\n/** Supported deterministic column generators. */\nexport const GeneratedColumnSchema = z.discriminatedUnion(\"generator\", [\n  z\n    .object({\n      name: identifier.describe(\"Column name.\"),\n      generator: z.literal(\"id\"),\n      description: nonBlankString.describe(\"Column business meaning.\"),\n    })\n    .strict(),\n  z\n    .object({\n      name: identifier.describe(\"Column name.\"),\n      generator: z.literal(\"date\"),\n      description: nonBlankString.describe(\"Column business meaning.\"),\n      days: z.number().int().min(30).max(1_095).describe(\"Generated history window in days.\"),\n    })\n    .strict(),\n  z\n    .object({\n      name: identifier.describe(\"Column name.\"),\n      generator: z.literal(\"category\"),\n      description: nonBlankString.describe(\"Column business meaning.\"),\n      values: z.array(nonBlankString.max(80)).min(2).max(12).describe(\"Skewed category values.\"),\n    })\n    .strict(),\n  z\n    .object({\n      name: identifier.describe(\"Column name.\"),\n      generator: z.literal(\"number\"),\n      description: nonBlankString.describe(\"Column business meaning.\"),\n      minimum: z.number().describe(\"Minimum generated value.\"),\n      maximum: z.number().describe(\"Maximum generated value.\"),\n      decimals: z.number().int().min(0).max(4).default(2).describe(\"Decimal precision.\"),\n    })\n    .strict(),\n  z\n    .object({\n      name: identifier.describe(\"Column name.\"),\n      generator: z.literal(\"boolean\"),\n      description: nonBlankString.describe(\"Column business meaning.\"),\n      trueProbability: z.number().min(0.01).max(0.99).describe(\"Share of true rows.\"),\n    })\n    .strict(),\n]);\n\n/** Deterministic generated column specification. */\nexport type GeneratedColumn = z.infer<typeof GeneratedColumnSchema>;\n\n/** KPI binding compiled into validation SQL and dashboard measures. */\nexport const GeneratedMetricSchema = ResearchedKpiSchema.extend({\n  aggregation: z\n    .enum([\"count\", \"sum\", \"average\"])\n    .describe(\"Safe aggregate compiled by the generator.\"),\n  column: identifier.optional().describe(\"Numeric source column; omitted for count.\"),\n}).strict();\n\n/** KPI binding. */\nexport type GeneratedMetric = z.infer<typeof GeneratedMetricSchema>;\n\n/** Structured plan compiled into SQL and presentation assets. */\nexport const GeneratorPlanSchema = z\n  .object({\n    table: identifier.describe(\"Primary generated Delta table name.\"),\n    rowCount: z.number().int().min(1_000).max(100_000).describe(\"Rows to generate.\"),\n    columns: z\n      .array(GeneratedColumnSchema)\n      .min(4)\n      .max(16)\n      .describe(\"Typed deterministic column generators.\"),\n    metrics: z.array(GeneratedMetricSchema).min(1).max(6).describe(\"Dashboard and Genie KPIs.\"),\n    story: nonBlankString.describe(\"Business anomaly and impact represented in the data.\"),\n    sampleQuestions: z\n      .array(nonBlankString.max(300))\n      .min(3)\n      .max(8)\n      .describe(\"Questions supported by the generated table.\"),\n  })\n  .strict()\n  .superRefine((value, ctx) => {\n    const names = new Set<string>();\n    for (const [index, column] of value.columns.entries()) {\n      if (names.has(column.name)) {\n        ctx.addIssue({\n          code: \"custom\",\n          path: [\"columns\", index, \"name\"],\n          message: \"Generated column names must be unique.\",\n        });\n      }\n      names.add(column.name);\n    }\n    if (!value.columns.some(({ generator }) => generator === \"id\")) {\n      ctx.addIssue({ code: \"custom\", path: [\"columns\"], message: \"An id column is required.\" });\n    }\n    if (!value.columns.some(({ generator }) => generator === \"date\")) {\n      ctx.addIssue({ code: \"custom\", path: [\"columns\"], message: \"A date column is required.\" });\n    }\n    if (!value.columns.some(({ generator }) => generator === \"category\")) {\n      ctx.addIssue({\n        code: \"custom\",\n        path: [\"columns\"],\n        message: \"A category column is required.\",\n      });\n    }\n    const numeric = new Set(\n      value.columns.filter(({ generator }) => generator === \"number\").map(({ name }) => name),\n    );\n    for (const [index, metric] of value.metrics.entries()) {\n      if (metric.aggregation !== \"count\" && (!metric.column || !numeric.has(metric.column))) {\n        ctx.addIssue({\n          code: \"custom\",\n          path: [\"metrics\", index, \"column\"],\n          message: \"Sum and average metrics require a generated numeric column.\",\n        });\n      }\n    }\n  })\n  .describe(\"Validated plan for deterministic synthetic data and analytics assets.\");\n\n/** Structured generator plan. */\nexport type GeneratorPlan = z.infer<typeof GeneratorPlanSchema>;\n\n/** Input for the standalone structured data-planning tool. */\nexport const PlanGeneratorDataRequestSchema = z\n  .object({\n    request: GeneratorRequestSchema,\n    brand: BrandPackageSchema,\n    kpiResearch: KpiResearchResultSchema,\n  })\n  .strict()\n  .describe(\"Inputs needed to build a typed generator plan.\");\n\n/** Input for the standalone structured data-planning tool. */\nexport type PlanGeneratorDataRequest = z.infer<typeof PlanGeneratorDataRequestSchema>;\n\n/** Location and trusted identity for one generated schema. */\nexport const GeneratedSchemaSchema = z\n  .object({\n    catalog: identifier.describe(\"Configured Unity Catalog.\"),\n    schema: identifier.describe(\"Per-user generated schema.\"),\n    fullName: nonBlankString.describe(\"Quoted-safe catalog.schema display name.\"),\n    principal: nonBlankString.describe(\"Trusted OBO Databricks user name.\"),\n  })\n  .strict()\n  .describe(\"Provisioned per-user Unity Catalog schema.\");\n\n/** Provisioned generated schema. */\nexport type GeneratedSchema = z.infer<typeof GeneratedSchemaSchema>;\n\n/** Input for per-user schema provisioning. */\nexport const ProvisionGeneratorSchemaRequestSchema = z\n  .object({\n    request: GeneratorRequestSchema.pick({ company: true, purpose: true }),\n  })\n  .strict()\n  .describe(\"Request to provision the active user's generated schema.\");\n\n/** Input for per-user schema provisioning. */\nexport type ProvisionGeneratorSchemaRequest = z.infer<typeof ProvisionGeneratorSchemaRequestSchema>;\n\n/** Input for generated data materialization. */\nexport const MaterializeGeneratorDataRequestSchema = z\n  .object({\n    location: GeneratedSchemaSchema,\n    plan: GeneratorPlanSchema,\n  })\n  .strict()\n  .describe(\"Request to materialize and validate generated Delta data.\");\n\n/** Input for generated data materialization. */\nexport type MaterializeGeneratorDataRequest = z.infer<typeof MaterializeGeneratorDataRequestSchema>;\n\n/** Created tables and KPI validation statements. */\nexport const MaterializedGeneratorDataSchema = z\n  .object({\n    tables: z.array(nonBlankString).min(1).describe(\"Created fully qualified Delta tables.\"),\n    validationStatements: z\n      .record(identifier, nonBlankString)\n      .describe(\"Statement IDs keyed by validated KPI name.\"),\n  })\n  .strict()\n  .describe(\"Materialized and validated generated data.\");\n\n/** Created tables and KPI validation statements. */\nexport type MaterializedGeneratorData = z.infer<typeof MaterializedGeneratorDataSchema>;\n\n/** Input shared by dashboard and standalone Genie creation tools. */\nexport const CreateGeneratorPresentationRequestSchema = z\n  .object({\n    request: GeneratorRequestSchema.pick({\n      company: true,\n      purpose: true,\n    }),\n    location: GeneratedSchemaSchema,\n    plan: GeneratorPlanSchema,\n    brand: BrandPackageSchema,\n  })\n  .strict()\n  .describe(\"Request to create a presentation asset over generated data.\");\n\n/** Input shared by dashboard and standalone Genie creation tools. */\nexport type CreateGeneratorPresentationRequest = z.infer<\n  typeof CreateGeneratorPresentationRequestSchema\n>;\n\n/** Dashboard output with its automatic companion Genie Agent. */\nexport const GeneratedDashboardSchema = z\n  .object({\n    dashboardId: nonBlankString.describe(\"Created Lakeview dashboard ID.\"),\n    path: nonBlankString.optional().describe(\"Workspace path, when returned.\"),\n    companionGenie: z.literal(\"AUTO\").describe(\"Dashboard-published companion Genie mode.\"),\n  })\n  .strict();\n\n/** Published dashboard with automatic companion Genie. */\nexport type GeneratedDashboard = z.infer<typeof GeneratedDashboardSchema>;\n\n/** Standalone Genie output used only when no dashboard is requested. */\nexport const GeneratedGenieSpaceSchema = z\n  .object({\n    spaceId: nonBlankString.describe(\"Created standalone Genie space ID.\"),\n    title: nonBlankString.describe(\"Genie space title.\"),\n  })\n  .strict();\n\n/** Created standalone Genie space. */\nexport type GeneratedGenieSpace = z.infer<typeof GeneratedGenieSpaceSchema>;\n\n/** Terminal workflow output. */\nexport const GeneratedAssetsSchema = z\n  .object({\n    request: GeneratorRequestSchema,\n    schema: GeneratedSchemaSchema,\n    tables: z.array(nonBlankString).min(1).describe(\"Created fully qualified Delta tables.\"),\n    brand: BrandPackageSchema,\n    kpiResearch: KpiResearchResultSchema,\n    plan: GeneratorPlanSchema,\n    dashboard: GeneratedDashboardSchema.optional(),\n    genie: GeneratedGenieSpaceSchema.optional(),\n  })\n  .strict()\n  .superRefine((value, ctx) => {\n    if ((value.dashboard === undefined) === (value.genie === undefined)) {\n      ctx.addIssue({\n        code: \"custom\",\n        message: \"Exactly one dashboard or standalone Genie space is required.\",\n      });\n    }\n  })\n  .describe(\"Generated Databricks data and presentation assets.\");\n\n/** Terminal generator workflow output. */\nexport type GeneratedAssets = z.infer<typeof GeneratedAssetsSchema>;\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/brand.ts","../src/kpi.ts","../src/workflow.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -1,6 +1,95 @@
 {
   "name": "@dbx-tools/shared-generator",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "description": "Browser-safe contracts and clients for AppKit generator workflows",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/reggie-db/dbx-tools.git",
+    "directory": "packages/js/shared/generator"
+  },
+  "scripts": {
+    "build": "projen build",
+    "compile": "projen compile",
+    "default": "projen default",
+    "package": "projen package",
+    "post-compile": "projen post-compile",
+    "pre-compile": "projen pre-compile",
+    "prepack": "projen prepack",
+    "test": "projen test",
+    "watch": "projen watch",
+    "projen": "projen"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "@dbx-tools/shared-core": "^0.9.136",
+    "zod": "4.3.6"
+  },
+  "main": "./lib/index.js",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public",
+    "main": "./lib/index.js",
+    "types": "./lib/index.d.ts",
+    "exports": {
+      ".": {
+        "types": "./lib/index.d.ts",
+        "default": "./lib/index.js"
+      },
+      "./brand": {
+        "types": "./lib/src/brand.d.ts",
+        "default": "./lib/src/brand.js"
+      },
+      "./kpi": {
+        "types": "./lib/src/kpi.d.ts",
+        "default": "./lib/src/kpi.js"
+      },
+      "./workflow": {
+        "types": "./lib/src/workflow.d.ts",
+        "default": "./lib/src/workflow.js"
+      },
+      "./*": {
+        "types": "./lib/src/*/index.d.ts",
+        "default": "./lib/src/*/index.js"
+      },
+      "./package.json": "./package.json"
+    }
+  },
+  "version": "0.9.136",
+  "types": "./lib/index.d.ts",
+  "dbxToolsConfig": {
+    "tags": [
+      "shared"
+    ]
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./brand": {
+      "types": "./lib/src/brand.d.ts",
+      "default": "./lib/src/brand.js"
+    },
+    "./kpi": {
+      "types": "./lib/src/kpi.d.ts",
+      "default": "./lib/src/kpi.js"
+    },
+    "./workflow": {
+      "types": "./lib/src/workflow.d.ts",
+      "default": "./lib/src/workflow.js"
+    },
+    "./*": {
+      "types": "./lib/src/*/index.d.ts",
+      "default": "./lib/src/*/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.ts",
+    "src",
+    "lib"
+  ],
+  "//": "~~ Generated by projen. To modify, edit .projenrc.js and run \"bunx projen\"."
+}

package/src/brand.ts

@@ -0,0 +1,273 @@
+/**
+ * Browser-safe contracts and client for AppKit brand generation.
+ *
+ * @module
+ */
+
+import { BrandContextSchema } from "@dbx-tools/shared-core/brand-utils";
+import { z } from "zod";
+
+const nonBlankString = z.string().trim().min(1);
+
+/** Registered AppKit generator plugin name. */
+export const GENERATOR_PLUGIN_NAME = "generator";
+
+/** Default route prefix published by the generator plugin. */
+export const GENERATOR_BASE_PATH = `/api/${GENERATOR_PLUGIN_NAME}`;
+
+/** Mount-relative route segments owned by the generator plugin. */
+export const GENERATOR_ROUTES = {
+  generateBrand: "/brand/generate",
+} as const;
+
+/** Input accepted by brand generation. */
+export const BrandGenerationRequestSchema = z
+  .object({
+    name: nonBlankString
+      .max(200)
+      .optional()
+      .describe("Known brand, organization, or product name."),
+    prompt: nonBlankString
+      .max(2_000)
+      .optional()
+      .describe("Open-ended brand brief used for research and generation."),
+    website: z
+      .string()
+      .url()
+      .refine((value) => new URL(value).protocol === "https:", "Expected an HTTPS website URL.")
+      .optional()
+      .describe("Known official website used to disambiguate the brand."),
+  })
+  .strict()
+  .refine((value) => value.name !== undefined || value.prompt !== undefined, {
+    message: "Brand generation requires a name or prompt.",
+  })
+  .describe("Request to research one brand and generate its portable branding package.");
+
+/** Validated brand-generation request. */
+export type BrandGenerationRequest = z.infer<typeof BrandGenerationRequestSchema>;
+
+/** A cited source and whether its page content was available to synthesis. */
+export const BrandPackageSourceSchema = z
+  .object({
+    url: z.string().url().describe("Source URL used during brand research."),
+    title: nonBlankString.optional().describe("Source page title, when available."),
+    snippet: nonBlankString.optional().describe("Search-result excerpt, when available."),
+    fetched: z
+      .boolean()
+      .describe("True when web_fetch returned page content used during synthesis."),
+  })
+  .strict()
+  .describe("Web source used to research the generated brand.");
+
+/** Source provenance included in a generated branding package. */
+export type BrandPackageSource = z.infer<typeof BrandPackageSourceSchema>;
+
+/** One fetched mobile-app image used as visual brand research. */
+export const BrandVisualImageSchema = z
+  .object({
+    url: z.string().url().describe("Original mobile-store image URL."),
+    contentType: z.string().optional().describe("Fetched image media type."),
+    localPath: z
+      .string()
+      .optional()
+      .describe("Package-relative exported image path, when written by a CLI."),
+  })
+  .strict()
+  .describe("Mobile-store image reference used for brand inspiration.");
+
+/** Mobile-store image used as visual brand research. */
+export type BrandVisualImage = z.infer<typeof BrandVisualImageSchema>;
+
+/** App Store or Play Store page and its visual references. */
+export const BrandVisualReferenceSchema = z
+  .object({
+    platform: z.enum(["ios", "android"]).describe("Mobile application platform."),
+    appName: nonBlankString.describe("Application name read from the store page."),
+    pageUrl: z.string().url().describe("Official application-store page."),
+    images: z.array(BrandVisualImageSchema).describe("Fetched app icon or screenshots."),
+  })
+  .strict()
+  .describe("Mobile application visuals consulted during brand research.");
+
+/** Mobile-store brand research reference. */
+export type BrandVisualReference = z.infer<typeof BrandVisualReferenceSchema>;
+
+/** Portable generated brand context with research provenance. */
+export const BrandPackageSchema = z
+  .object({
+    brand: BrandContextSchema.describe(
+      "Portable brand context ready for @dbx-tools UI and email consumers.",
+    ),
+    sources: z
+      .array(BrandPackageSourceSchema)
+      .describe("Deduplicated web sources used to generate this package."),
+    visualReferences: z
+      .array(BrandVisualReferenceSchema)
+      .default([])
+      .describe("iOS and Android application visuals used for inspiration."),
+  })
+  .strict()
+  .describe("Generated branding package and its web research provenance.");
+
+/** Generated branding package. */
+export type BrandPackage = z.infer<typeof BrandPackageSchema>;
+
+/** Observable stages in one brand-generation workflow. */
+export const BrandGenerationStageSchema = z.enum([
+  "search",
+  "fetch",
+  "visuals",
+  "assets",
+  "synthesize",
+]);
+
+/** Observable brand-generation stage. */
+export type BrandGenerationStage = z.infer<typeof BrandGenerationStageSchema>;
+
+/** Progress emitted while the backend researches and synthesizes a brand. */
+export const BrandGenerationProgressEventSchema = z
+  .object({
+    type: z.literal("progress"),
+    stage: BrandGenerationStageSchema.describe("Current workflow stage."),
+    message: nonBlankString.describe("Short user-facing progress message."),
+    current: z.number().int().nonnegative().optional().describe("Completed items in this stage."),
+    total: z.number().int().positive().optional().describe("Total items in this stage."),
+  })
+  .strict()
+  .describe("Progress update from a running brand generation.");
+
+/** Progress event emitted during brand generation. */
+export type BrandGenerationProgressEvent = z.infer<typeof BrandGenerationProgressEventSchema>;
+
+/** Final successful brand-generation event. */
+export const BrandGenerationResultEventSchema = z
+  .object({
+    type: z.literal("result"),
+    package: BrandPackageSchema.describe("Completed portable branding package."),
+  })
+  .strict()
+  .describe("Successful completion of brand generation.");
+
+/** Final successful brand-generation event. */
+export type BrandGenerationResultEvent = z.infer<typeof BrandGenerationResultEventSchema>;
+
+/** Final error event from a started brand-generation stream. */
+export const BrandGenerationErrorEventSchema = z
+  .object({
+    type: z.literal("error"),
+    message: nonBlankString.describe("Actionable generation failure message."),
+  })
+  .strict()
+  .describe("Failure emitted after a brand-generation stream started.");
+
+/** Final error event from a started brand-generation stream. */
+export type BrandGenerationErrorEvent = z.infer<typeof BrandGenerationErrorEventSchema>;
+
+/** Every server-sent event emitted by brand generation. */
+export const BrandGenerationEventSchema = z.discriminatedUnion("type", [
+  BrandGenerationProgressEventSchema,
+  BrandGenerationResultEventSchema,
+  BrandGenerationErrorEventSchema,
+]);
+
+/** Server-sent event emitted by brand generation. */
+export type BrandGenerationEvent = z.infer<typeof BrandGenerationEventSchema>;
+
+/** Browser-safe route configuration published by the AppKit generator plugin. */
+export const GeneratorClientConfigSchema = z
+  .object({
+    basePath: nonBlankString.describe("Mounted API route prefix for the generator plugin."),
+  })
+  .strict()
+  .describe("Browser configuration published by the AppKit generator plugin.");
+
+/** Browser-safe generator plugin route configuration. */
+export type GeneratorClientConfig = z.infer<typeof GeneratorClientConfigSchema>;
+
+/** Options for one browser brand-generation stream. */
+export interface BrandGenerationStreamOptions {
+  /** Cancels the request and response stream. */
+  signal?: AbortSignal;
+  /** Fetch implementation. Defaults to the browser global. */
+  fetch?: typeof globalThis.fetch;
+}
+
+/** Build the brand endpoint from the generator plugin's published base path. */
+export function brandGenerateUrl(basePath: string = GENERATOR_BASE_PATH): string {
+  return `${basePath.replace(/\/+$/, "")}${GENERATOR_ROUTES.generateBrand}`;
+}
+
+/** Parse one complete SSE frame into its validated brand event. */
+function parseEventFrame(frame: string): BrandGenerationEvent | undefined {
+  const data = frame
+    .split("\n")
+    .filter((line) => line.startsWith("data:"))
+    .map((line) => line.slice(5).trimStart())
+    .join("\n");
+  if (!data) return undefined;
+  const value: unknown = JSON.parse(data);
+  return BrandGenerationEventSchema.parse(value);
+}
+
+/** Read a failed HTTP response without trusting its payload shape. */
+async function responseError(response: Response): Promise<string> {
+  const value: unknown = await response
+    .clone()
+    .json()
+    .catch(() => undefined);
+  if (typeof value === "object" && value !== null && "error" in value) {
+    const message = value.error;
+    if (typeof message === "string" && message.trim()) return message.trim();
+  }
+  const text = await response.text().catch(() => "");
+  return text.trim() || `Brand generation failed (${response.status}).`;
+}
+
+/** Browser client for the generator plugin's streamed routes. */
+export class GeneratorPluginClient {
+  private readonly config: GeneratorClientConfig;
+
+  /** Create a client from the plugin's published `clientConfig()` payload. */
+  constructor(config: GeneratorClientConfig) {
+    this.config = GeneratorClientConfigSchema.parse(config);
+  }
+
+  /** Generate a brand while yielding validated progress and terminal events. */
+  async *generate(
+    input: BrandGenerationRequest,
+    options: BrandGenerationStreamOptions = {},
+  ): AsyncGenerator<BrandGenerationEvent> {
+    const request = BrandGenerationRequestSchema.parse(input);
+    const fetcher = options.fetch ?? globalThis.fetch.bind(globalThis);
+    const response = await fetcher(brandGenerateUrl(this.config.basePath), {
+      method: "POST",
+      headers: {
+        Accept: "text/event-stream",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(request),
+      ...(options.signal ? { signal: options.signal } : {}),
+    });
+    if (!response.ok) throw new Error(await responseError(response));
+    if (!response.body) throw new Error("Brand generation returned no event stream.");
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    for (;;) {
+      const { done, value } = await reader.read();
+      buffer += decoder.decode(value, { stream: !done }).replaceAll("\r\n", "\n");
+      let boundary = buffer.indexOf("\n\n");
+      while (boundary >= 0) {
+        const event = parseEventFrame(buffer.slice(0, boundary));
+        if (event) yield event;
+        buffer = buffer.slice(boundary + 2);
+        boundary = buffer.indexOf("\n\n");
+      }
+      if (done) break;
+    }
+    const event = parseEventFrame(buffer.trim());
+    if (event) yield event;
+  }
+}