@protoyard/blueprint 0.0.0-stage → 1.1.1

package/dist/runtime-definition.js

@@ -0,0 +1,74 @@
+import { definePrototype, parseManifest, } from '@protoyard/core';
+import { deriveAppModel } from "./app-model.js";
+import { brandLibraryThemeId, resolveBlueprintBrand } from "./brand.js";
+import { blueprintGeneratorVersion } from "./generator-version.js";
+import { deriveDatabaseVersions, latestSchemaVersion } from "./migrations.js";
+import { derivePolicy } from "./policy.js";
+import { blueprintScenarios } from "./scenarios.js";
+import { deriveIntegrity } from "./storage.js";
+/** Scenario a blueprint prototype opens in (one of `blueprintScenarios`). */
+export const BLUEPRINT_DEFAULT_SCENARIO = 'active';
+/**
+ * The theme id a blueprint opens in: its library theme, the id of the theme
+ * its brand builds, or null without a brand. `protoyard generate` writes it to
+ * `protoyard.json` and the player uses it as `defaultTheme`. Throws
+ * `BrandThemeError` for an unknown library theme or a brand that fails AA.
+ */
+export function brandDefaultThemeId(blueprint) {
+    if (!blueprint.brand)
+        return null;
+    const libraryTheme = brandLibraryThemeId(blueprint.brand);
+    if (libraryTheme)
+        return libraryTheme;
+    return resolveBlueprintBrand(blueprint.brand, { blueprintName: blueprint.name }).id;
+}
+/** The theme a blueprint's brand builds, or null for no brand or a library brand (shipped by id). */
+export function blueprintBrandTheme(blueprint) {
+    if (!blueprint.brand || brandLibraryThemeId(blueprint.brand))
+        return null;
+    return resolveBlueprintBrand(blueprint.brand, { blueprintName: blueprint.name });
+}
+/**
+ * Builds a `definePrototype`-valid definition from a parsed blueprint, plus
+ * its app model. The world generator loads lazily (`@protoyard/blueprint/generator`
+ * stays out of the caller's initial chunk until a scenario seeds).
+ */
+export function definePrototypeFromBlueprint(blueprint, options) {
+    const slug = options.slug ?? options.namespace;
+    const scenarios = blueprintScenarios(blueprint);
+    const appModel = deriveAppModel(blueprint);
+    const theme = blueprintBrandTheme(blueprint);
+    const manifest = parseManifest({
+        id: `local.${slug}`,
+        slug,
+        kind: 'prototype',
+        name: blueprint.name,
+        description: blueprint.description ?? '',
+        version: options.version ?? '0.1.0',
+        category: blueprint.category ?? blueprint.catalog?.category ?? 'general',
+        tags: blueprint.tags,
+        ...(blueprint.icon ? { icon: blueprint.icon } : {}),
+        defaultScenario: BLUEPRINT_DEFAULT_SCENARIO,
+        defaultTheme: brandDefaultThemeId(blueprint) ?? 'violet',
+        preview: {
+            viewport: 'desktop',
+            layout: { id: appModel.layout.id },
+        },
+        storage: { namespace: options.namespace, schemaVersion: latestSchemaVersion(blueprint) },
+        scenarios: scenarios.map((scenario) => scenario.id),
+    });
+    const definition = definePrototype({
+        manifest,
+        database: { versions: deriveDatabaseVersions(blueprint) },
+        scenarios,
+        policy: derivePolicy(blueprint),
+        integrity: deriveIntegrity(blueprint),
+        ...(theme ? { themes: [theme] } : {}),
+        async generate(ctx) {
+            const { createBlueprintGenerator } = await import("./generator.js");
+            return createBlueprintGenerator(blueprint).generate(ctx);
+        },
+        generatorVersion: blueprintGeneratorVersion(blueprint),
+    });
+    return { definition, appModel };
+}

package/dist/scenarios.d.ts

@@ -0,0 +1,9 @@
+import type { ScenarioDefinition } from '@protoyard/core';
+import type { Blueprint } from './schema.ts';
+/**
+ * Default scenarios for a blueprint-backed prototype. These are deliberately
+ * product-generic; the blueprint parameter keeps scenario selection at the
+ * validated blueprint boundary and leaves room for future data-only scenario
+ * options without requiring each player or template to duplicate defaults.
+ */
+export declare function blueprintScenarios(_blueprint: Blueprint): ScenarioDefinition[];

package/dist/scenarios.js

@@ -0,0 +1,49 @@
+/**
+ * Default scenarios for a blueprint-backed prototype. These are deliberately
+ * product-generic; the blueprint parameter keeps scenario selection at the
+ * validated blueprint boundary and leaves room for future data-only scenario
+ * options without requiring each player or template to duplicate defaults.
+ */
+export function blueprintScenarios(_blueprint) {
+    return [
+        {
+            id: 'empty',
+            name: 'Empty',
+            description: 'Team only — no records yet.',
+            seed: 123_001,
+            referenceTime: '2026-06-01T09:00:00.000Z',
+            density: 'empty',
+            organization: { size: 4, ageDays: 30, subscription: 'pro' },
+        },
+        {
+            id: 'active',
+            extends: 'workspace-owner',
+            name: 'Active',
+            description: 'A normal density workspace for day-to-day demos.',
+            seed: 123_002,
+            referenceTime: '2026-06-01T14:00:00.000Z',
+            density: 'normal',
+            organization: { size: 6, ageDays: 120, subscription: 'pro' },
+        },
+        {
+            id: 'viewer',
+            extends: 'read-only-viewer',
+            name: 'Viewer',
+            description: 'Read-only stroll through seeded work.',
+            seed: 123_003,
+            referenceTime: '2026-06-01T11:00:00.000Z',
+            density: 'sparse',
+            organization: { size: 5, ageDays: 60, subscription: 'pro' },
+        },
+        {
+            id: 'massive',
+            extends: 'workspace-owner',
+            name: 'Massive',
+            description: 'Dense seed for list virtualization and budget checks.',
+            seed: 123_004,
+            referenceTime: '2026-06-01T16:00:00.000Z',
+            density: 'massive',
+            organization: { size: 12, ageDays: 365, subscription: 'enterprise' },
+        },
+    ];
+}