@datashow/super-visual-compiler 0.0.0-stage → 0.1.0-rc.1

package/package.json

@@ -1,6 +1,31 @@
 {
   "name": "@datashow/super-visual-compiler",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-rc.1",
+  "description": "Compile governed React applications into inspectable Super Visual solution bundles.",
+  "type": "module",
+  "exports": "./src/index.mjs",
+  "files": [
+    "src",
+    "template"
+  ],
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Datashow-Pty-Ltd/super-visual.git",
+    "directory": "packages/compiler"
+  },
+  "homepage": "https://github.com/Datashow-Pty-Ltd/super-visual#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@datashow/super-visual-compliance": "0.1.0-rc.1",
+    "@datashow/super-visual-contracts": "0.1.0-rc.1",
+    "@datashow/super-visual-semantic": "0.1.0-rc.1",
+    "fflate": "0.8.3",
+    "yaml": "2.9.1"
+  }
+}

package/src/build-solution.mjs

@@ -0,0 +1,140 @@
+import { createHash } from "node:crypto";
+import { cp, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import YAML from "yaml";
+import { loadContract, resolveProjectPath } from "@datashow/super-visual-contracts";
+import { compileBrokerAdapter, compileTmdl, semanticModelWithCatalog } from "@datashow/super-visual-semantic";
+import { generateRuntimeManifests, validateCompilation } from "./index.mjs";
+import { generateReportWrapper } from "./report-wrapper.mjs";
+
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const runtimeSource = path.resolve(packageRoot, "../runtime-powerbi/src");
+const visualTemplate = path.join(packageRoot, "template", "visual");
+
+async function readStructured(file) {
+  const source = await readFile(file, "utf8");
+  return file.endsWith(".json") ? JSON.parse(source) : YAML.parse(source);
+}
+
+async function files(root, relative = "") {
+  const entries = await readdir(path.join(root, relative), { withFileTypes: true });
+  const output = [];
+  for (const entry of entries) {
+    const child = path.join(relative, entry.name);
+    if (entry.isDirectory()) output.push(...await files(root, child));
+    else output.push(child);
+  }
+  return output.sort();
+}
+
+async function hashes(root) {
+  const output = {};
+  for (const relative of await files(root)) {
+    if (relative === "supervisual.manifest.json") continue;
+    output[relative.split(path.sep).join("/")] = createHash("sha256").update(await readFile(path.join(root, relative))).digest("hex");
+  }
+  return output;
+}
+
+export async function refreshSolutionManifest(outputDirectory) {
+  const manifestPath = path.join(outputDirectory, "supervisual.manifest.json");
+  const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+  manifest.files = await hashes(outputDirectory);
+  await writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+  return manifest;
+}
+
+export async function verifySolutionManifest(outputDirectory) {
+  const manifestPath = path.join(outputDirectory, "supervisual.manifest.json");
+  const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+  const actual = await hashes(outputDirectory);
+  const expected = manifest.files ?? {};
+  const missing = Object.keys(expected).filter((file) => !(file in actual));
+  const unexpected = Object.keys(actual).filter((file) => !(file in expected));
+  const changed = Object.keys(expected).filter((file) => actual[file] && actual[file] !== expected[file]);
+  return { ok: missing.length === 0 && unexpected.length === 0 && changed.length === 0, missing, unexpected, changed, fileCount: Object.keys(actual).length };
+}
+
+async function generateVisual(project, inputs, visualRoot) {
+  await cp(visualTemplate, visualRoot, { recursive: true });
+  await cp(runtimeSource, path.join(visualRoot, "src"), { recursive: true });
+  await generateRuntimeManifests(inputs, visualRoot);
+  const pbivizPath = path.join(visualRoot, "pbiviz.json");
+  const pbiviz = JSON.parse(await readFile(pbivizPath, "utf8"));
+  pbiviz.visual = { ...pbiviz.visual, ...project.target.visual };
+  pbiviz.apiVersion = project.target.visual.apiVersion;
+  await writeFile(pbivizPath, `${JSON.stringify(pbiviz, null, 2)}\n`);
+  const packagePath = path.join(visualRoot, "package.json");
+  const manifest = JSON.parse(await readFile(packagePath, "utf8"));
+  manifest.name = `${project.application.id}-powerbi`;
+  manifest.version = project.target.visual.version.split(".").slice(0, 3).join(".");
+  await writeFile(packagePath, `${JSON.stringify(manifest, null, 2)}\n`);
+  return visualRoot;
+}
+
+export async function loadProject(projectFile) {
+  const root = path.dirname(path.resolve(projectFile));
+  const project = await loadContract("supervisual-project", path.resolve(projectFile));
+  const semanticModel = await readStructured(resolveProjectPath(root, project.semantic.model));
+  const broker = await loadContract("widget-broker", resolveProjectPath(root, project.semantic.broker));
+  const pageSet = await loadContract("page-set", resolveProjectPath(root, project.semantic.pageSet));
+  const reportSource = await loadContract("report-source-bundle", resolveProjectPath(root, project.source.bundle));
+  return { root, project, semanticModel, broker, pageSet, reportSource };
+}
+
+export async function buildSolution(projectFile, options = {}) {
+  const loaded = await loadProject(projectFile);
+  const { root, project, broker, pageSet, reportSource } = loaded;
+  const semanticModel = options.semanticParameters
+    ? { ...loaded.semanticModel, sourceParameters: { ...loaded.semanticModel.sourceParameters, ...options.semanticParameters } }
+    : loaded.semanticModel;
+  const diagnostics = validateCompilation({ semanticModel, broker, pageSet, reportSource });
+  if (diagnostics.length) throw new Error(`Compilation failed:\n- ${diagnostics.join("\n- ")}`);
+  const output = options.outputDirectory ?? resolveProjectPath(root, project.output.directory);
+  await rm(output, { recursive: true, force: true });
+  await mkdir(output, { recursive: true });
+  await writeFile(path.join(output, "compliance.report.json"), `${JSON.stringify({
+    contractVersion: 1,
+    ok: true,
+    policies: project.compliance?.policies ?? ["core", "powerbi"],
+    checks: ["project-contract", "widget-broker", "page-set-primitives", "report-graph-bindings", "report-source-policy", "semantic-references"],
+    diagnostics: [],
+  }, null, 2)}\n`);
+  const baseModel = path.join(output, "Base.SemanticModel");
+  const adapterBaseModel = path.join(output, ".SemanticAdapterBase.SemanticModel");
+  const adapterModel = path.join(output, "SemanticAdapter.SemanticModel");
+  const visual = path.join(output, "Visual");
+  const report = path.join(output, "Report.Report");
+  await compileTmdl(semanticModel, baseModel);
+  const brokerSemanticModel = semanticModelWithCatalog(semanticModel, broker, options.semanticCatalogSource ?? semanticModel);
+  const brokerBaseModel = brokerSemanticModel === semanticModel ? baseModel : adapterBaseModel;
+  if (brokerBaseModel === baseModel) {
+    await compileBrokerAdapter({ baseModelDirectory: baseModel, outputDirectory: adapterModel, broker, semanticModel: brokerSemanticModel });
+  } else {
+    await compileTmdl(brokerSemanticModel, brokerBaseModel);
+    try {
+      await compileBrokerAdapter({ baseModelDirectory: brokerBaseModel, outputDirectory: adapterModel, broker, semanticModel: brokerSemanticModel });
+    } finally {
+      await rm(brokerBaseModel, { recursive: true, force: true });
+    }
+  }
+  await generateVisual(project, { broker, pageSet, reportSource }, visual);
+  await generateReportWrapper({ outputDirectory: report, title: project.application.title, visualGuid: project.target.visual.guid });
+  const manifest = {
+    contractVersion: 1,
+    application: project.application,
+    target: project.target,
+    inputs: { project: path.basename(projectFile), semanticModel: project.semantic.model, broker: project.semantic.broker, pageSet: project.semantic.pageSet, reportSource: project.source.bundle },
+    outputs: { baseModel: "Base.SemanticModel", semanticAdapter: "SemanticAdapter.SemanticModel", visualSource: "Visual", report: "Report.Report" },
+    provenance: {
+      compiler: "@datashow/super-visual-compiler",
+      reference: "AdventureWorks deployed v38",
+      semanticParameterOverrides: Object.keys(options.semanticParameters ?? {}).sort(),
+      semanticCatalogSource: options.semanticCatalogSource ? { id: options.semanticCatalogSource.id ?? null, displayName: options.semanticCatalogSource.displayName ?? options.semanticCatalogSource.name ?? null } : null,
+    },
+    files: await hashes(output),
+  };
+  await writeFile(path.join(output, "supervisual.manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`);
+  return { outputDirectory: output, diagnostics: [], manifest };
+}

package/src/embed-visual.mjs

@@ -0,0 +1,24 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import path from "node:path";
+import { unzipSync } from "fflate";
+
+export async function embedVisualPackage(pbivizPath, reportDirectory) {
+  const archive = unzipSync(new Uint8Array(await readFile(pbivizPath)));
+  const packageBytes = archive["package.json"];
+  if (!packageBytes) throw new Error("The .pbiviz archive is missing package.json");
+  const packageManifest = JSON.parse(Buffer.from(packageBytes).toString("utf8"));
+  const guid = packageManifest.visual?.guid;
+  const resource = packageManifest.resources?.[0]?.file;
+  if (!guid || !resource || !archive[resource]) throw new Error("The .pbiviz archive does not identify its visual resource");
+  const target = path.join(reportDirectory, "CustomVisuals", guid);
+  await mkdir(path.join(target, "resources"), { recursive: true });
+  await writeFile(path.join(target, "package.json"), Buffer.from(packageBytes));
+  const resourceName = path.basename(resource);
+  await writeFile(path.join(target, "resources", resourceName), Buffer.from(archive[resource]));
+  const reportPath = path.join(reportDirectory, "definition", "report.json");
+  const report = JSON.parse(await readFile(reportPath, "utf8"));
+  report.resourcePackages = (report.resourcePackages ?? []).filter((item) => item.name !== guid);
+  report.resourcePackages.push({ name: guid, type: "CustomVisual", items: [{ name: `resources/${resourceName}`, path: resourceName, type: "CustomVisualMetadata" }] });
+  await writeFile(reportPath, `${JSON.stringify(report, null, 2)}\n`);
+  return { guid, resourceName, reportDirectory };
+}

package/src/index.mjs

@@ -0,0 +1,69 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { validatePageSetPrimitives, validateReportGraphBindings, validateSourceBundle, validateWidgetBrokerContract } from "@datashow/super-visual-compliance";
+import { semanticModelWithCatalog } from "@datashow/super-visual-semantic";
+
+function moduleText(comment, name, value) {
+  return `${comment}\nexport const ${name} = ${JSON.stringify(value, null, 2)} as const;\n`;
+}
+
+function qualifiedReference(value) {
+  if (typeof value !== "string" || !value.endsWith("]")) return null;
+  const separator = value.lastIndexOf("[", value.length - 2);
+  if (separator <= 0 || separator === value.length - 2) return null;
+  return { table: value.slice(0, separator), object: value.slice(separator + 1, -1) };
+}
+
+export function validateCompilation({ semanticModel, broker, pageSet, reportSource }) {
+  const brokerSemanticModel = semanticModelWithCatalog(semanticModel, broker);
+  return [
+    ...validateWidgetBrokerContract(broker, brokerSemanticModel),
+    ...validateReportGraphBindings(pageSet, broker),
+    ...validatePageSetPrimitives(pageSet),
+    ...validateSourceBundle(reportSource).map((diagnostic) => `${diagnostic.code}: ${diagnostic.path} ${diagnostic.message}`),
+  ];
+}
+
+export async function generateRuntimeManifests({ broker, pageSet, reportSource }, outputRoot) {
+  const referenced = new Set((pageSet.pages ?? []).flatMap((page) => [
+    page.summary?.emphasisBinding?.dataset,
+    page.search?.dataset,
+    ...(page.kpis ?? []).map((kpi) => kpi.binding?.dataset),
+    ...(page.widgets ?? []).map((widget) => widget.dataset),
+  ]).filter(Boolean));
+  for (const interaction of pageSet.interactions ?? []) for (const id of interaction.invalidates ?? []) referenced.add(id);
+  const widgets = broker.widgets.filter((widget) => referenced.has(widget.id));
+  const sourceRoot = path.join(outputRoot, "src");
+  await mkdir(sourceRoot, { recursive: true });
+  await writeFile(path.join(sourceRoot, "datasetRegistry.ts"), `export const DATASET_KEYS = ${JSON.stringify(widgets.map((widget) => widget.id))} as const;\nexport type DatasetKey = string;\n`);
+  await writeFile(path.join(sourceRoot, "pageSetManifest.ts"), moduleText("/* Generated from the page-set contract. */", "PAGE_SET_MANIFEST", pageSet));
+  const dependencies = Object.fromEntries(widgets.filter((widget) => widget.selectable).map((widget) => [widget.id, widget.invalidates.filter((id) => referenced.has(id))]));
+  await writeFile(path.join(sourceRoot, "dependencyManifest.ts"), `import type { DatasetKey } from "./datasetRegistry";\nexport const SELECTION_DEPENDENCIES: Record<DatasetKey, DatasetKey[]> = ${JSON.stringify(dependencies, null, 2)};\n`);
+  const manifest = Object.fromEntries(widgets.map((widget) => [widget.id, { id: widget.id, order: ["top-by-value", "bottom-by-value"].includes(widget.rowSelection) ? "value" : "axis", selectable: widget.selectable }]));
+  await writeFile(path.join(sourceRoot, "widgetManifest.ts"), `import type { DatasetKey } from "./model";\nexport const WIDGET_MANIFEST: Record<DatasetKey, { id: DatasetKey; order: "axis" | "value"; selectable: boolean }> = ${JSON.stringify(manifest, null, 2)};\n`);
+  const targets = Object.fromEntries(widgets.map((widget) => {
+    const reference = qualifiedReference(widget.axis);
+    if (!reference) throw new Error(`Broker axis must use Table[Column] notation: ${widget.axis}`);
+    return [widget.id, { table: reference.table, column: reference.object }];
+  }));
+  await writeFile(path.join(sourceRoot, "filterTargets.ts"), `import type { DatasetKey } from "./model";\nimport type { FilterTarget } from "./filter";\nexport const FILTER_TARGETS: Record<DatasetKey, FilterTarget> = ${JSON.stringify(targets, null, 2)};\n`);
+  const claudeParameters = reportSource.adapter?.kind === "claude-dashboard" ? reportSource.adapter.parameters : [];
+  const claudeTargets = Object.fromEntries(claudeParameters.map((parameter) => {
+    const reference = qualifiedReference(parameter.target);
+    if (!reference) throw new Error(`Claude parameter target must use Table[Column] notation: ${parameter.target}`);
+    return [parameter.name, { table: reference.table, column: reference.object }];
+  }));
+  const claudeValueMaps = Object.fromEntries(claudeParameters.filter((parameter) => parameter.values).map((parameter) => [parameter.name, parameter.values]));
+  await writeFile(path.join(sourceRoot, "claudeParamTargets.ts"), `import type { FilterTarget, FilterValue } from "./filter";\nexport const CLAUDE_PARAM_FILTER_TARGETS: Record<string, FilterTarget> = ${JSON.stringify(claudeTargets, null, 2)};\nconst CLAUDE_PARAM_VALUE_MAPS: Record<string, Record<string, FilterValue>> = ${JSON.stringify(claudeValueMaps, null, 2)};\nexport function claudeFilterValues(name: string, value: unknown): FilterValue[] {\n  const values = Array.isArray(value) ? value : [value];\n  const mapped = CLAUDE_PARAM_VALUE_MAPS[name] ?? {};\n  return values.flatMap((candidate) => {\n    if (candidate === null || candidate === undefined || candidate === \"\") return [];\n    const resolved = mapped[String(candidate)] ?? candidate;\n    return typeof resolved === \"string\" || typeof resolved === \"number\" || typeof resolved === \"boolean\" ? [resolved] : [];\n  });\n}\n`);
+  for (const file of reportSource.files) {
+    const target = path.resolve(outputRoot, file.path);
+    if (target !== path.resolve(outputRoot) && !target.startsWith(`${path.resolve(outputRoot)}${path.sep}`)) throw new Error(`Generated source escapes output: ${file.path}`);
+    await mkdir(path.dirname(target), { recursive: true });
+    await writeFile(target, file.content, "utf8");
+  }
+  return { datasets: widgets.map((widget) => widget.id), generatedFiles: 6 + reportSource.files.length };
+}
+
+export { buildSolution, loadProject, refreshSolutionManifest, verifySolutionManifest } from "./build-solution.mjs";
+export { generateReportWrapper } from "./report-wrapper.mjs";
+export { embedVisualPackage } from "./embed-visual.mjs";

package/src/report-wrapper.mjs

@@ -0,0 +1,88 @@
+import { createHash } from "node:crypto";
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+function id(seed, length = 20) {
+  return createHash("sha256").update(seed).digest("hex").slice(0, length);
+}
+
+function uuid(seed) {
+  const bytes = createHash("sha256").update(seed).digest().subarray(0, 16);
+  bytes[6] = ((bytes[6] ?? 0) & 0x0f) | 0x50;
+  bytes[8] = ((bytes[8] ?? 0) & 0x3f) | 0x80;
+  const hex = bytes.toString("hex");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
+async function json(file, value) {
+  await mkdir(path.dirname(file), { recursive: true });
+  await writeFile(file, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function projection(role, property, kind = "Column") {
+  return {
+    field: { [kind]: { Expression: { SourceRef: { Entity: "Widget Axis" } }, Property: property } },
+    queryRef: `Widget Axis.${property}`,
+    nativeQueryRef: property,
+  };
+}
+
+export async function generateReportWrapper({ outputDirectory, title, visualGuid, semanticPath = "../SemanticAdapter.SemanticModel", background = "#F6F5EF" }) {
+  const pageName = id(`${title}:page`);
+  const visualName = id(`${title}:visual`);
+  const definition = path.join(outputDirectory, "definition");
+  await json(path.join(outputDirectory, ".platform"), {
+    $schema: "https://developer.microsoft.com/json-schemas/fabric/gitIntegration/platformProperties/2.0.0/schema.json",
+    metadata: { type: "Report", displayName: title },
+    config: { version: "2.0", logicalId: uuid(`${title}:report`) },
+  });
+  await json(path.join(outputDirectory, "definition.pbir"), {
+    $schema: "https://developer.microsoft.com/json-schemas/fabric/item/report/definitionProperties/2.0.0/schema.json",
+    version: "4.0", datasetReference: { byPath: { path: semanticPath } },
+  });
+  await json(path.join(definition, "version.json"), {
+    $schema: "https://developer.microsoft.com/json-schemas/fabric/item/report/definition/versionMetadata/1.0.0/schema.json",
+    version: "2.0.0",
+  });
+  await json(path.join(definition, "report.json"), {
+    $schema: "https://developer.microsoft.com/json-schemas/fabric/item/report/definition/report/3.3.0/schema.json",
+    themeCollection: { baseTheme: { name: "CY24SU10", reportVersionAtImport: { visual: "2.6.0", report: "3.1.0", page: "2.3.0" }, type: "SharedResources" } },
+    resourcePackages: [],
+    settings: { useStylableVisualContainerHeader: true, exportDataMode: "AllowSummarized" },
+  });
+  await json(path.join(definition, "pages", "pages.json"), {
+    $schema: "https://developer.microsoft.com/json-schemas/fabric/item/report/definition/pagesMetadata/1.0.0/schema.json",
+    pageOrder: [pageName], activePageName: pageName,
+  });
+  await json(path.join(definition, "pages", pageName, "page.json"), {
+    $schema: "https://developer.microsoft.com/json-schemas/fabric/item/report/definition/page/2.1.0/schema.json",
+    name: pageName, displayName: title, displayOption: "FitToPage", height: 1080, width: 1920,
+    objects: Object.fromEntries(["background", "outspace"].map((name) => [name, [{ properties: { color: { solid: { color: { expr: { Literal: { Value: `'${background}'` } } } } }, transparency: { expr: { Literal: { Value: "0D" } } } } }]])),
+  });
+  await json(path.join(definition, "pages", pageName, "visuals", visualName, "visual.json"), {
+    $schema: "https://developer.microsoft.com/json-schemas/fabric/item/report/definition/visualContainer/2.12.0/schema.json",
+    name: visualName,
+    position: { x: 0, y: 0, z: 0, height: 1080, width: 1920, tabOrder: 0 },
+    visual: {
+      visualType: visualGuid,
+      query: { queryState: {
+        widgetId: { projections: [projection("widgetId", "WidgetId")] },
+        axisKey: { projections: [projection("axisKey", "AxisKey")] },
+        label: { projections: [projection("label", "Label")] },
+        sort: { projections: [projection("sort", "Sort")] },
+        seriesKey: { projections: [projection("seriesKey", "SeriesKey")] },
+        seriesLabel: { projections: [projection("seriesLabel", "SeriesLabel")] },
+        value: { projections: [projection("value", "Widget Value", "Measure")] },
+        context: { projections: [projection("context", "Broker Context", "Measure")] },
+      } },
+      visualContainerObjects: {
+        general: [{ properties: { altText: { expr: { Literal: { Value: `'${title.replaceAll("'", "''")} compiled analytical application.'` } } } } }],
+        title: [{ properties: { show: { expr: { Literal: { Value: "false" } } } } }],
+        background: [{ properties: { show: { expr: { Literal: { Value: "false" } } } } }],
+        border: [{ properties: { show: { expr: { Literal: { Value: "false" } } } } }],
+        visualHeader: [{ properties: { show: { expr: { Literal: { Value: "false" } } } } }],
+      },
+    },
+  });
+  return { pageName, visualName, outputDirectory };
+}

package/template/visual/capabilities.json

@@ -0,0 +1,41 @@
+{
+  "dataRoles": [
+    { "name": "widgetId", "displayName": "Broker — widget ID", "kind": "Grouping" },
+    { "name": "axisKey", "displayName": "Broker — axis key", "kind": "Grouping" },
+    { "name": "label", "displayName": "Broker — label", "kind": "Grouping" },
+    { "name": "sort", "displayName": "Broker — sort", "kind": "Grouping" },
+    { "name": "seriesKey", "displayName": "Broker — series key", "kind": "Grouping" },
+    { "name": "seriesLabel", "displayName": "Broker — series label", "kind": "Grouping" },
+    { "name": "value", "displayName": "Broker — value", "kind": "Measure" },
+    { "name": "context", "displayName": "Broker — context", "kind": "Measure" }
+  ],
+  "objects": {
+    "general": {
+      "displayName": "General",
+      "properties": {
+        "filter": { "displayName": "Business filter", "type": { "filter": true } },
+        "selfFilter": { "displayName": "Widget request", "type": { "filter": { "selfFilter": true } } }
+      }
+    }
+  },
+  "dataViewMappings": [{
+    "conditions": [{
+      "widgetId": { "min": 1, "max": 1 }, "axisKey": { "min": 1, "max": 1 },
+      "label": { "min": 1, "max": 1 }, "sort": { "min": 1, "max": 1 },
+      "seriesKey": { "max": 1 }, "seriesLabel": { "max": 1 },
+      "value": { "min": 1, "max": 1 }, "context": { "min": 1, "max": 1 }
+    }],
+    "table": { "rows": { "select": [
+      { "for": { "in": "widgetId" } }, { "for": { "in": "axisKey" } },
+      { "for": { "in": "label" } }, { "for": { "in": "sort" } },
+      { "for": { "in": "seriesKey" } }, { "for": { "in": "seriesLabel" } },
+      { "for": { "in": "value" } }, { "for": { "in": "context" } }
+    ], "dataReductionAlgorithm": { "top": { "count": 30000 } } } }
+  }],
+  "supportsHighlight": false,
+  "supportsKeyboardFocus": true,
+  "supportsSynchronizingFilterState": true,
+  "supportsLandingPage": true,
+  "supportsEmptyDataView": true,
+  "privileges": []
+}

package/template/visual/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "super-visual-generated-powerbi",
+  "version": "1.0.0",
+  "private": true,
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --passWithNoTests",
+    "package": "pbiviz package"
+  },
+  "dependencies": {
+    "@fontsource/source-serif-4": "5.3.1",
+    "@nivo/bar": "0.99.0",
+    "@nivo/line": "0.99.0",
+    "@nivo/pie": "0.99.0",
+    "@nivo/sankey": "^0.99.0",
+    "@nivo/tree": "0.99.0",
+    "d3": "7.9.0",
+    "powerbi-visuals-api": "5.11.1",
+    "react": "19.3.1",
+    "react-dom": "19.3.1",
+    "react-router-dom": "7.18.4"
+  },
+  "devDependencies": {
+    "@types/d3": "7.4.3",
+    "@types/react": "19.3.0",
+    "@types/react-dom": "19.3.0",
+    "powerbi-visuals-tools": "7.2.1",
+    "typescript": "5.9.3",
+    "vitest": "5.0.5"
+  }
+}

package/template/visual/pbiviz.json

@@ -0,0 +1,20 @@
+{
+  "visual": {
+    "name": "superVisualGenerated",
+    "displayName": "Super Visual",
+    "guid": "superVisualGenerated000000000000000000000000",
+    "visualClassName": "Visual",
+    "version": "1.0.0.0",
+    "description": "A compiled, semantically bound analytical application.",
+    "supportUrl": "https://github.com/Datashow-Pty-Ltd/super-visual",
+    "gitHubUrl": "https://github.com/Datashow-Pty-Ltd/super-visual"
+  },
+  "apiVersion": "5.11.1",
+  "author": { "name": "Datashow", "email": "support@datashow.com.au" },
+  "assets": { "icon": "assets/icon.png" },
+  "externalJS": null,
+  "style": "style/visual.less",
+  "capabilities": "capabilities.json",
+  "dependencies": null,
+  "stringResources": []
+}

package/template/visual/src/styles.d.ts

@@ -0,0 +1 @@
+declare module "*.less";

package/template/visual/src/visual.ts

@@ -0,0 +1,139 @@
+"use strict";
+
+import { createElement } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import powerbi from "powerbi-visuals-api";
+import "./../style/visual.less";
+import { ReportApplication } from "./reportApplication";
+import { buildBrokerAdapter, completeRequestedDatasets } from "./dataView";
+import { dependentWidgets } from "./dependency";
+import { buildBasicFilter, filterValueFromLabel } from "./filter";
+import { FILTER_TARGETS } from "./filterTargets";
+import { CLAUDE_PARAM_FILTER_TARGETS, claudeFilterValues } from "./claudeParamTargets";
+import type { ClaudeParams } from "./claudeDashboard/types";
+import { DATASET_KEYS, emptyDatasets, emptyStatuses, type ActiveSelections, type DashboardModel, type DatasetKey, type MetricPoint, type WidgetStatus } from "./model";
+
+import IVisual = powerbi.extensibility.visual.IVisual;
+import IVisualHost = powerbi.extensibility.visual.IVisualHost;
+import VisualConstructorOptions = powerbi.extensibility.visual.VisualConstructorOptions;
+import VisualUpdateOptions = powerbi.extensibility.visual.VisualUpdateOptions;
+
+const BROKER_TARGET = { table: "Widget Axis", column: "WidgetId" };
+const DATASET_SET = new Set<string>(DATASET_KEYS);
+
+export class Visual implements IVisual {
+  private readonly host: IVisualHost;
+  private readonly root: Root;
+  private readonly datasets = emptyDatasets();
+  private readonly status: Record<DatasetKey, WidgetStatus> = emptyStatuses();
+  private readonly selections: ActiveSelections = {};
+  private visible: DatasetKey[] = [...DATASET_KEYS];
+  private context = "";
+  private warnings: string[] = [];
+  private sequence = 0;
+  private readonly handleSelect = (widget: DatasetKey, point: MetricPoint): void => this.select(widget, point);
+  private readonly handleClear = (widget: DatasetKey): void => this.clear(widget);
+  private readonly handleVisibleDatasets = (datasets: DatasetKey[]): void => this.request(datasets);
+  private readonly handleClaudeParams = (changes: ClaudeParams): void => this.applyClaudeParams(changes);
+  private readonly handleClaudeRefresh = (dataset: string): void => this.refreshClaudeDataset(dataset);
+  private readonly handleClaudeLink = (name: string): void => { void name; };
+
+  constructor(options: VisualConstructorOptions | undefined) {
+    if (!options) throw new Error("Power BI did not provide visual constructor options");
+    this.host = options.host;
+    options.element.replaceChildren();
+    options.element.dataset.reportScrollRoot = "";
+    options.element.style.height = "100%";
+    options.element.style.overflowY = "auto";
+    this.root = createRoot(options.element);
+    this.render();
+  }
+
+  update(options: VisualUpdateOptions): void {
+    this.sequence += 1;
+    this.host.eventService.renderingStarted(options);
+    try {
+      const adapter = buildBrokerAdapter(options.dataViews, this.host);
+      const completed = completeRequestedDatasets(adapter, this.visible);
+      for (const key of DATASET_KEYS) {
+        if (completed[key]) {
+          this.datasets[key] = completed[key]!;
+          this.status[key] = "fresh";
+        }
+      }
+      this.context = adapter.context || this.context;
+      this.warnings = adapter.warnings;
+      this.render();
+      this.host.eventService.renderingFinished(options);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.host.eventService.renderingFailed(options, message);
+    }
+  }
+
+  destroy(): void { this.root.unmount(); }
+  getFormattingModel(): powerbi.visuals.FormattingModel { return { cards: [] }; }
+
+  private request(datasets: DatasetKey[]): void {
+    this.visible = [...new Set(datasets)].filter((key) => DATASET_SET.has(key));
+    for (const key of this.visible) if (!this.datasets[key]) this.status[key] = "loading";
+    const filter = buildBasicFilter(BROKER_TARGET, ...this.visible);
+    this.host.applyJsonFilter(filter, "general", "selfFilter", powerbi.FilterAction.merge);
+    this.render();
+  }
+
+  private select(widget: DatasetKey, point: MetricPoint): void {
+    const value = filterValueFromLabel(point.dimensions.at(-1)?.key || point.axisKey);
+    this.selections[widget] = { widget, pointKey: point.key, label: point.label, value };
+    for (const key of dependentWidgets(widget)) this.status[key] = "stale";
+    this.host.applyJsonFilter(buildBasicFilter(FILTER_TARGETS[widget], value), "general", "filter", powerbi.FilterAction.merge);
+    this.render();
+  }
+
+  private clear(widget: DatasetKey): void {
+    delete this.selections[widget];
+    this.host.applyJsonFilter(buildBasicFilter(FILTER_TARGETS[widget], this.selections[widget]?.value ?? ""), "general", "filter", powerbi.FilterAction.remove);
+    this.render();
+  }
+
+  private applyClaudeParams(changes: ClaudeParams): void {
+    if (this.host.hostCapabilities.allowInteractions === false) return;
+    for (const [name, value] of Object.entries(changes)) {
+      const target = CLAUDE_PARAM_FILTER_TARGETS[name];
+      if (!target) continue;
+      const values = claudeFilterValues(name, value);
+      const filter = buildBasicFilter(target, ...values);
+      this.host.applyJsonFilter(filter, "general", "filter", values.length ? powerbi.FilterAction.merge : powerbi.FilterAction.remove);
+    }
+    for (const key of this.visible) this.status[key] = "stale";
+    this.request(this.visible);
+  }
+
+  private refreshClaudeDataset(dataset: string): void {
+    if (DATASET_SET.has(dataset)) this.request([dataset as DatasetKey]);
+  }
+
+  private model(): DashboardModel {
+    const rowCounts = Object.fromEntries(DATASET_KEYS.map((key) => [key, this.datasets[key]?.points.length ?? 0])) as Record<DatasetKey, number>;
+    const valueSums = Object.fromEntries(DATASET_KEYS.map((key) => [key, this.datasets[key]?.points.reduce((sum, point) => sum + point.value, 0) ?? 0])) as Record<DatasetKey, number>;
+    return { datasets: this.datasets, status: this.status, warnings: this.warnings, diagnostics: {
+      dataViewCount: 0, updateSequence: this.sequence, dataUpdateSequence: this.sequence, requestSequence: 0,
+      receivedWidgets: DATASET_KEYS.filter((key) => Boolean(this.datasets[key])), receivedRowCount: Object.values(rowCounts).reduce((sum, value) => sum + value, 0),
+      widgetStatus: this.status, rowCounts, valueSums, selectionCandidates: Object.fromEntries(DATASET_KEYS.map((key) => [key, (this.datasets[key]?.points ?? []).map((point) => ({ key: point.key, label: point.label }))])) as DashboardModel["diagnostics"]["selectionCandidates"],
+      activeSelections: Object.fromEntries(Object.entries(this.selections).map(([key, value]) => [key, value?.label ?? ""])), activeRequest: this.visible,
+      context: this.context, lastRequestMs: null, events: [],
+    } };
+  }
+
+  private render(): void {
+    this.root.render(createElement(ReportApplication, {
+      model: this.model(), selections: this.selections,
+      onSelect: this.handleSelect,
+      onClear: this.handleClear,
+      onVisibleDatasetsChange: this.handleVisibleDatasets,
+      onClaudeParamsChange: this.handleClaudeParams,
+      onClaudeRefresh: this.handleClaudeRefresh,
+      onClaudeLinkChange: this.handleClaudeLink,
+    }));
+  }
+}

package/template/visual/style/visual.less

@@ -0,0 +1,7 @@
+:root { color-scheme: light; }
+* { box-sizing: border-box; }
+html, body, #root { margin: 0; width: 100%; min-height: 100%; }
+body { overflow: hidden; }
+button, input, select { font: inherit; }
+[data-report-scroll-root] { width: 100%; min-height: 100%; overflow: visible; }
+@import "./report-design.less";

package/template/visual/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "allowJs": false,
+    "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "jsx": "react-jsx",
+    "lib": ["ES2022", "DOM"],
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "resolveJsonModule": true,
+    "sourceMap": true,
+    "declaration": true,
+    "outDir": "./.tmp/build/",
+    "skipLibCheck": true,
+    "strict": true,
+    "target": "ES2022"
+  },
+  "files": ["./src/visual.ts", "./src/styles.d.ts"]
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.