@almadar/core 10.0.0 → 10.2.0

package/dist/builders.d.ts

@@ -1,10 +1,33 @@
-import { U as UISlot, E as Effect, T as Trait, R as RenderBinding, a as RenderUIEffect, b as TraitEventContract, c as Entity, d as TraitEventListener, e as TraitConfig, f as EntityField, g as EntityPersistence, h as EntityRow, i as TraitRef, j as TraitReference } from './trait-CjyEE6Di.js';
-import { U as UseDeclaration, E as EntityRef, P as PageRef, O as OrbitalDefinition, a as OrbitalSchema, b as Page, c as PageRefObject } from './schema-BetbBFJb.js';
+import { T as TraitConfig, U as UISlot, E as Effect, a as Trait, R as RenderBinding, b as RenderUIEffect, c as TraitEventContract, d as Entity, e as TraitEventListener, f as EntityField, g as EntityPersistence, h as EntityRow, i as TraitRef, j as TraitReference } from './trait-Bhssodu6.js';
+import { O as OrbitalSchema, U as UseDeclaration, E as EntityRef, P as PageRef, a as OrbitalDefinition, b as Page, c as PageRefObject } from './schema-lxLUgVSb.js';
 import { S as SExpr } from './expression-BVRFm0sV.js';
-export { C as ComposeBehaviorsInput, a as ComposeBehaviorsResult, E as EventWiringEntry, L as LayoutStrategy, b as applyEventWiring, c as composeBehaviors, d as detectLayoutStrategy } from './compose-behaviors-DAYTsIWZ.js';
+export { C as ComposeBehaviorsInput, a as ComposeBehaviorsResult, E as EventWiringEntry, L as LayoutStrategy, b as applyEventWiring, c as composeBehaviors, d as detectLayoutStrategy } from './compose-behaviors-DM0gUoSO.js';
 import { AnyPatternConfig } from '@almadar/patterns';
 import 'zod';
 
+/**
+ * Apply trait config overrides to a schema — pure, returns a new schema.
+ *
+ * Used by config-driven preview surfaces (the playground property inspector and
+ * the verify config-sweep) to render a behavior with different `config` values
+ * WITHOUT recompiling: the override is written onto the matching trait, then the
+ * schema is re-registered and re-rendered.
+ *
+ * The resolved schema's traits are inlined `Trait`s whose `config` is the
+ * DECLARED schema (`{ field: { type, default, ... } }`), so an override patches
+ * each field's `default`. A trait that instead carries call-site value config
+ * (a `{ ref, config }` reference) gets the values merged directly.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Return a new schema with `config` overrides applied to traits whose identity
+ * (`name`, falling back to `ref`) matches a key in `overrides`. Fields not
+ * declared on the trait are ignored — overrides never invent config.
+ */
+declare function applyTraitConfigOverrides(schema: OrbitalSchema, overrides: Readonly<Record<string, TraitConfig>>): OrbitalSchema;
+
 /**
  * Layout-Trait Builders
  *
@@ -437,4 +460,4 @@ declare function compose(orbitals: (OrbitalDefinition | OrbitalSchema)[], pages:
  */
 declare function pipe(orbitals: (OrbitalDefinition | OrbitalSchema)[], events: TraitEventContract[], appName?: string): OrbitalSchema;
 
-export { type ComposeConnection, type ComposePage, type MakeAtomOrbitalOpts, type MakeAtomOrbitalTraitOverrides, type MakeEntityOpts, type MakeLayoutTraitOpts, type MakeOrbitalWithUsesOpts, type MakePageOpts, type MakePageRefOpts, type MakePageRefOptsTyped, type MakeTraitRefOpts, type MakeTraitRefOptsTyped, compose, connect, ensureIdField, extractTrait, makeAtomOrbital, makeEntity, makeLayoutTrait, makeOrbital, makeOrbitalWithUses, makePage, makePageRef, makeRenderUI, makeSchema, makeSlot, makeTraitRef, mergeOrbitals, pipe, plural, wire };
+export { type ComposeConnection, type ComposePage, type MakeAtomOrbitalOpts, type MakeAtomOrbitalTraitOverrides, type MakeEntityOpts, type MakeLayoutTraitOpts, type MakeOrbitalWithUsesOpts, type MakePageOpts, type MakePageRefOpts, type MakePageRefOptsTyped, type MakeTraitRefOpts, type MakeTraitRefOptsTyped, applyTraitConfigOverrides, compose, connect, ensureIdField, extractTrait, makeAtomOrbital, makeEntity, makeLayoutTrait, makeOrbital, makeOrbitalWithUses, makePage, makePageRef, makeRenderUI, makeSchema, makeSlot, makeTraitRef, mergeOrbitals, pipe, plural, wire };

package/dist/builders.js

@@ -185,6 +185,14 @@ z.object({
   basePath: z.string(),
   mappings: z.record(AssetMappingSchema)
 });
+var AssetCatalogEntrySchema = z.object({
+  url: z.string(),
+  name: z.string(),
+  category: z.string(),
+  kind: z.enum(["image", "spritesheet", "audio", "scene", "portrait", "model", "other"]),
+  thumbnailUrl: z.string().optional()
+});
+z.array(AssetCatalogEntrySchema);
 
 // src/types/entity.ts
 var EntityPersistenceSchema = z.enum([
@@ -318,7 +326,13 @@ var TraitConfigValueSchema = z.lazy(
 var TraitConfigSchema = z.record(TraitConfigValueSchema);
 var ConfigFieldDeclarationSchema = z.object({
   type: z.string(),
-  default: TraitConfigValueSchema.optional()
+  default: TraitConfigValueSchema.optional(),
+  label: z.string().optional(),
+  description: z.string().optional(),
+  tier: z.string().optional(),
+  values: z.array(z.string()).optional(),
+  synonyms: z.string().optional(),
+  control: z.enum(["icon", "asset", "color", "text", "number", "boolean", "select"]).optional()
 });
 var DeclaredTraitConfigSchema = z.record(
   ConfigFieldDeclarationSchema
@@ -1150,6 +1164,43 @@ z.object({
   suggestedGuards: z.array(SuggestedGuardSchema).optional()
 });
 
+// src/builders/apply-config-overrides.ts
+function overrideTrait(trait, values) {
+  if ("scope" in trait) {
+    const config = trait.config;
+    if (config === void 0) return trait;
+    const next = { ...config };
+    for (const [field, value] of Object.entries(values)) {
+      const decl = config[field];
+      if (decl !== void 0) {
+        next[field] = { ...decl, default: value };
+      }
+    }
+    return { ...trait, config: next };
+  }
+  const base = trait.config !== void 0 ? { ...trait.config } : {};
+  return { ...trait, config: { ...base, ...values } };
+}
+function traitIdentity(trait) {
+  if (trait.name !== void 0) return trait.name;
+  return "ref" in trait ? trait.ref : void 0;
+}
+function applyTraitConfigOverrides(schema, overrides) {
+  if (overrides === void 0 || Object.keys(overrides).length === 0) return schema;
+  return {
+    ...schema,
+    orbitals: schema.orbitals.map((orbital) => ({
+      ...orbital,
+      traits: orbital.traits.map((trait) => {
+        if (typeof trait === "string") return trait;
+        const id = traitIdentity(trait);
+        const values = id !== void 0 ? overrides[id] : void 0;
+        return values !== void 0 ? overrideTrait(trait, values) : trait;
+      })
+    }))
+  };
+}
+
 // src/builders/layout-strategy.ts
 function hasSequentialChain(wiring) {
   if (wiring.length < 2) {
@@ -1683,6 +1734,6 @@ function pipe(orbitals, events, appName) {
   };
 }
 
-export { applyEventWiring, compose, composeBehaviors, connect, detectLayoutStrategy, ensureIdField, extractTrait, makeAtomOrbital, makeEntity, makeLayoutTrait, makeOrbital, makeOrbitalWithUses, makePage, makePageRef, makeRenderUI, makeSchema, makeSlot, makeTraitRef, mergeOrbitals, pipe, plural, wire };
+export { applyEventWiring, applyTraitConfigOverrides, compose, composeBehaviors, connect, detectLayoutStrategy, ensureIdField, extractTrait, makeAtomOrbital, makeEntity, makeLayoutTrait, makeOrbital, makeOrbitalWithUses, makePage, makePageRef, makeRenderUI, makeSchema, makeSlot, makeTraitRef, mergeOrbitals, pipe, plural, wire };
 //# sourceMappingURL=builders.js.map
 //# sourceMappingURL=builders.js.map