@usefragments/core 1.10.2 → 2.0.0

package/dist/manifest.d.ts

@@ -0,0 +1,228 @@
+import { z } from 'zod';
+
+/**
+ * Design-system manifest v1 — the committed, human-curated vocabulary that
+ * every local agent surface reads. FCID is `contractHash(manifest)`.
+ */
+
+declare const FRAGMENTS_MANIFEST_FILENAME = "fragments.manifest.json";
+declare const FRAGMENTS_MANIFEST_SCHEMA_VERSION = 1;
+declare const FRAGMENTS_MANIFEST_TOKEN_RULE = "no-raw-values";
+declare const fragmentsManifestPrimitiveSchema: z.ZodObject<{
+    name: z.ZodString;
+    members: z.ZodArray<z.ZodString, "many">;
+    intents: z.ZodArray<z.ZodString, "many">;
+    props: z.ZodArray<z.ZodString, "many">;
+    do: z.ZodArray<z.ZodString, "many">;
+    dont: z.ZodArray<z.ZodString, "many">;
+    exemplar: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    props: string[];
+    name: string;
+    members: string[];
+    intents: string[];
+    do: string[];
+    dont: string[];
+    exemplar?: string | undefined;
+}, {
+    props: string[];
+    name: string;
+    members: string[];
+    intents: string[];
+    do: string[];
+    dont: string[];
+    exemplar?: string | undefined;
+}>;
+declare const fragmentsManifestPatternSchema: z.ZodObject<{
+    name: z.ZodString;
+    intent: z.ZodString;
+    primitives: z.ZodArray<z.ZodString, "many">;
+    shape: z.ZodString;
+    exemplar: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    shape: string;
+    name: string;
+    intent: string;
+    primitives: string[];
+    exemplar?: string | undefined;
+}, {
+    shape: string;
+    name: string;
+    intent: string;
+    primitives: string[];
+    exemplar?: string | undefined;
+}>;
+declare const fragmentsManifestGrammarSchema: z.ZodObject<{
+    rule: z.ZodString;
+    check: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    rule: string;
+    check?: string | undefined;
+}, {
+    rule: string;
+    check?: string | undefined;
+}>;
+declare const fragmentsManifestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    designSystem: z.ZodObject<{
+        packageName: z.ZodString;
+        importPath: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        importPath: string;
+        packageName: string;
+    }, {
+        importPath: string;
+        packageName: string;
+    }>;
+    tokens: z.ZodObject<{
+        prefix: z.ZodString;
+        rule: z.ZodLiteral<"no-raw-values">;
+    }, "strip", z.ZodTypeAny, {
+        rule: "no-raw-values";
+        prefix: string;
+    }, {
+        rule: "no-raw-values";
+        prefix: string;
+    }>;
+    primitives: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        members: z.ZodArray<z.ZodString, "many">;
+        intents: z.ZodArray<z.ZodString, "many">;
+        props: z.ZodArray<z.ZodString, "many">;
+        do: z.ZodArray<z.ZodString, "many">;
+        dont: z.ZodArray<z.ZodString, "many">;
+        exemplar: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        props: string[];
+        name: string;
+        members: string[];
+        intents: string[];
+        do: string[];
+        dont: string[];
+        exemplar?: string | undefined;
+    }, {
+        props: string[];
+        name: string;
+        members: string[];
+        intents: string[];
+        do: string[];
+        dont: string[];
+        exemplar?: string | undefined;
+    }>, "many">;
+    patterns: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        intent: z.ZodString;
+        primitives: z.ZodArray<z.ZodString, "many">;
+        shape: z.ZodString;
+        exemplar: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        shape: string;
+        name: string;
+        intent: string;
+        primitives: string[];
+        exemplar?: string | undefined;
+    }, {
+        shape: string;
+        name: string;
+        intent: string;
+        primitives: string[];
+        exemplar?: string | undefined;
+    }>, "many">;
+    grammar: z.ZodArray<z.ZodObject<{
+        rule: z.ZodString;
+        check: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        rule: string;
+        check?: string | undefined;
+    }, {
+        rule: string;
+        check?: string | undefined;
+    }>, "many">;
+    rules: z.ZodObject<{
+        preset: z.ZodString;
+        off: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        preset: string;
+        off: string[];
+    }, {
+        preset: string;
+        off: string[];
+    }>;
+}, "strip", z.ZodTypeAny, {
+    schemaVersion: 1;
+    tokens: {
+        rule: "no-raw-values";
+        prefix: string;
+    };
+    rules: {
+        preset: string;
+        off: string[];
+    };
+    primitives: {
+        props: string[];
+        name: string;
+        members: string[];
+        intents: string[];
+        do: string[];
+        dont: string[];
+        exemplar?: string | undefined;
+    }[];
+    designSystem: {
+        importPath: string;
+        packageName: string;
+    };
+    patterns: {
+        shape: string;
+        name: string;
+        intent: string;
+        primitives: string[];
+        exemplar?: string | undefined;
+    }[];
+    grammar: {
+        rule: string;
+        check?: string | undefined;
+    }[];
+}, {
+    schemaVersion: 1;
+    tokens: {
+        rule: "no-raw-values";
+        prefix: string;
+    };
+    rules: {
+        preset: string;
+        off: string[];
+    };
+    primitives: {
+        props: string[];
+        name: string;
+        members: string[];
+        intents: string[];
+        do: string[];
+        dont: string[];
+        exemplar?: string | undefined;
+    }[];
+    designSystem: {
+        importPath: string;
+        packageName: string;
+    };
+    patterns: {
+        shape: string;
+        name: string;
+        intent: string;
+        primitives: string[];
+        exemplar?: string | undefined;
+    }[];
+    grammar: {
+        rule: string;
+        check?: string | undefined;
+    }[];
+}>;
+type FragmentsManifestPrimitive = z.infer<typeof fragmentsManifestPrimitiveSchema>;
+type FragmentsManifestPattern = z.infer<typeof fragmentsManifestPatternSchema>;
+type FragmentsManifestGrammar = z.infer<typeof fragmentsManifestGrammarSchema>;
+type FragmentsManifest = z.infer<typeof fragmentsManifestSchema>;
+declare function parseFragmentsManifest(input: unknown): FragmentsManifest;
+/** FCID for a parsed manifest: content-address, key-order independent. */
+declare function fragmentsManifestFcid(manifest: FragmentsManifest): string;
+
+export { FRAGMENTS_MANIFEST_FILENAME, FRAGMENTS_MANIFEST_SCHEMA_VERSION, FRAGMENTS_MANIFEST_TOKEN_RULE, type FragmentsManifest, type FragmentsManifestGrammar, type FragmentsManifestPattern, type FragmentsManifestPrimitive, fragmentsManifestFcid, fragmentsManifestGrammarSchema, fragmentsManifestPatternSchema, fragmentsManifestPrimitiveSchema, fragmentsManifestSchema, parseFragmentsManifest };

package/dist/manifest.js

@@ -0,0 +1,24 @@
+import {
+  FRAGMENTS_MANIFEST_FILENAME,
+  FRAGMENTS_MANIFEST_SCHEMA_VERSION,
+  FRAGMENTS_MANIFEST_TOKEN_RULE,
+  fragmentsManifestFcid,
+  fragmentsManifestGrammarSchema,
+  fragmentsManifestPatternSchema,
+  fragmentsManifestPrimitiveSchema,
+  fragmentsManifestSchema,
+  parseFragmentsManifest
+} from "./chunk-7ULGH74M.js";
+import "./chunk-PWIJMOI4.js";
+export {
+  FRAGMENTS_MANIFEST_FILENAME,
+  FRAGMENTS_MANIFEST_SCHEMA_VERSION,
+  FRAGMENTS_MANIFEST_TOKEN_RULE,
+  fragmentsManifestFcid,
+  fragmentsManifestGrammarSchema,
+  fragmentsManifestPatternSchema,
+  fragmentsManifestPrimitiveSchema,
+  fragmentsManifestSchema,
+  parseFragmentsManifest
+};
+//# sourceMappingURL=manifest.js.map

package/dist/manifest.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/preview/index.js

@@ -825,6 +825,18 @@ function clipRegionToSize(region, size) {
 }
 
 // src/preview/validation.ts
+var PREVIEWABILITY_VALUES = /* @__PURE__ */ new Set([
+  "ready",
+  "building",
+  "needs-preview-provider",
+  "missing-dependency",
+  "missing-asset",
+  "server-only",
+  "unsupported-framework",
+  "runtime-error",
+  "build-error",
+  "docs-only"
+]);
 function definePreviewArtifactManifest(manifest) {
   const validation = validatePreviewArtifactManifest(manifest);
   if (!validation.ok) {
@@ -909,12 +921,25 @@ function validateComponents(value, issues) {
     issues.push("components must be an object");
     return;
   }
+  const normalizedComponentKeys = /* @__PURE__ */ new Set();
   for (const [key, component] of Object.entries(value)) {
     if (!isRecord(component)) {
       issues.push(`components.${key} must be an object`);
       continue;
     }
-    requireString(component, "componentKey", issues, `components.${key}`);
+    const componentKey = component.componentKey;
+    if (typeof componentKey !== "string" || !componentKey.trim()) {
+      issues.push(`components.${key}.componentKey must be a non-empty string`);
+    } else {
+      if (key !== componentKey) {
+        issues.push(`components.${key}.componentKey must match its components map key`);
+      }
+      const normalizedComponentKey = componentKey.trim();
+      if (normalizedComponentKeys.has(normalizedComponentKey)) {
+        issues.push(`components contains duplicate normalized componentKey ${componentKey}`);
+      }
+      normalizedComponentKeys.add(normalizedComponentKey);
+    }
     requireString(component, "publicRef", issues, `components.${key}`);
     requireString(component, "displayName", issues, `components.${key}`);
     requireString(component, "exportName", issues, `components.${key}`);
@@ -925,17 +950,33 @@ function validateComponents(value, issues) {
         `components.${key}.definitionSource must be one of typescript, fragment, manual, synthesized`
       );
     }
+    if (!isPreviewability(component.previewability)) {
+      issues.push(
+        `components.${key}.previewability must be one of ${[...PREVIEWABILITY_VALUES].join(", ")}`
+      );
+    }
     if (!isRecord(component.props)) {
       issues.push(`components.${key}.props must be an object`);
     }
     if (!Array.isArray(component.variants)) {
       issues.push(`components.${key}.variants must be an array`);
     } else {
+      const normalizedVariantIds = /* @__PURE__ */ new Set();
       component.variants.forEach((variant, index) => {
         if (!isRecord(variant)) {
           issues.push(`components.${key}.variants.${index} must be an object`);
           return;
         }
+        const variantPath = `components.${key}.variants.${index}`;
+        if (typeof variant.id !== "string" || !variant.id.trim()) {
+          issues.push(`${variantPath}.id must be a non-empty string`);
+        } else {
+          const normalizedVariantId = variant.id.trim();
+          if (normalizedVariantIds.has(normalizedVariantId)) {
+            issues.push(`${variantPath}.id must be unique within the component`);
+          }
+          normalizedVariantIds.add(normalizedVariantId);
+        }
         validateDesignReference(
           variant.design,
           issues,
@@ -1063,6 +1104,9 @@ function isRecord(value) {
 function isPreviewDefinitionSource(value) {
   return value === "typescript" || value === "fragment" || value === "manual" || value === "synthesized";
 }
+function isPreviewability(value) {
+  return typeof value === "string" && PREVIEWABILITY_VALUES.has(value);
+}
 function isFiniteNumber(value) {
   return typeof value === "number" && Number.isFinite(value);
 }