@wildo-ai/platform-core-shared 1.1.0 → 1.1.2

package/dist/esm/workbench/workbench-resources.custom.shared.schemas.d.ts

@@ -1,65 +1,243 @@
 import { z } from 'zod';
 /**
- * An application's shared MODULE and the resources it owns — derived, never stored.
+ * One relationship, as it rides on BOTH resources it joins.
  *
- * The first resource backed by `PersistenceAdapter.INTROSPECTION`. Rows come from the companion's
- * `resource-specifications` behavior, whose `moduleOwnership` is exactly this shape
- * (`{ moduleId, resourceTypes }`), so nothing is reshaped on the way through: the binding names the
- * behavior and the path, and the schema describes what that behavior already answers.
+ * ## Why an edge appears on two rows rather than on one
  *
- * ## Why `moduleId` is the primary key
+ * A relationship genuinely IS a property of both resources — "what is `deals` related to?" is a
+ * question about `deals` and about everything `deals` touches — so carrying it on both is a
+ * statement of what it means, not an encoding chosen to fit a row shape. Hanging every edge off one
+ * arbitrarily-chosen endpoint would be the encoding, and the choice would have to be re-derived by
+ * every reader.
  *
- * There is no store to mint a surrogate in. A derived row must be identified by something the SOURCE
- * already guarantees unique, and a module id is that by construction — two modules with one id would
- * be a defect in the application, not in this projection.
+ * The consumer draws each edge once, keyed by {@link relationshipId}. The duplication costs one extra
+ * copy of a small object per edge and buys a row that is complete on its own.
+ *
+ * ## Why the vocabularies are plain strings
+ *
+ * These values cross a subprocess boundary from the OBSERVED application's registry, which may be
+ * built against a different engine revision than the workbench. Binding `nature` or the cardinalities to the engine enums would make a
+ * row the observed application can legitimately produce unparseable here — the workbench refusing to
+ * show exactly the drift it exists to reveal.
  */
-export declare const Workbench_ApplicationModule_Schema: z.ZodObject<{
-    moduleId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    resourceTypes: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodString>>;
-    kind: z.ZodNullable<z.ZodString>;
-    contributions: z.ZodArray<z.ZodObject<{
-        contribution: z.ZodString;
-        count: z.ZodNumber;
-    }, z.core.$strip>>;
+export declare const Workbench_DomainResourceRelationship_Schema: z.ZodObject<{
+    relationshipId: z.ZodString;
+    resourceType1: z.ZodString;
+    resourceType2: z.ZodString;
+    cardinality1: z.ZodString;
+    cardinality2: z.ZodString;
+    nature: z.ZodString;
+    foreignKeyField: z.ZodNullable<z.ZodString>;
+    foreignKeyHolderResourceType: z.ZodString;
+    jointResourceType: z.ZodNullable<z.ZodString>;
+    isPrimaryScope: z.ZodBoolean;
+    isDisabled: z.ZodBoolean;
+    accessScopeStrategy: z.ZodNullable<z.ZodString>;
+    parentResourceRequirement: z.ZodNullable<z.ZodString>;
+    primaryScope: z.ZodNullable<z.ZodString>;
+    allowCycle: z.ZodBoolean;
 }, z.core.$strip>;
-export type Workbench_ApplicationModule = z.infer<typeof Workbench_ApplicationModule_Schema>;
+export type Workbench_DomainResourceRelationship = z.infer<typeof Workbench_DomainResourceRelationship_Schema>;
 /**
- * One relationship edge between two of the observed application's resources.
+ * ONE resource of the observed application's domain model — node, module membership, specification
+ * and edges in a single row.
  *
- * ## Where the shape comes from
+ * ## Why every field is a summary field
  *
- * MEASURED against a live `resources-registry` derivation rather than transcribed from the engine's
- * `ResourceRelationship` type: 16 edges, 12 keys present on all of them and `primaryScope` on 8. The
- * engine type carries more than the behavior emits, and a schema written from the type would refuse
- * every row for fields the projection never sends.
+ * A LIST renders the SUMMARY projection, and this resource's list IS its whole purpose: the graph
+ * consumes the collection. A field left out of the summary is a field the graph cannot draw, and the
+ * omission is silent — the row arrives, the field is simply absent. So the summary here is the full
+ * row by design rather than by neglect.
  *
- * ## Why the vocabularies are plain strings here
+ * ## Why this is one row per RESOURCE rather than one row per module or one row for the graph
  *
- * `nature`, `cardinality*` and `accessScopeStrategy` ARE closed engine enums, and this is one of the
- * documented exceptions rather than an oversight: these rows cross a subprocess boundary as JSON
- * from the OBSERVED application's registry, which may be built against a different engine revision
- * than the workbench. Binding to the enum would make a row the observed app can legitimately produce
- * unparseable here — the workbench would refuse to show exactly the drift it exists to reveal. This
- * is a projection of someone else's runtime, not an authored value the framework controls.
+ * Edges are resource-to-resource. A module-per-node projection would have to AGGREGATE them, which
+ * destroys precisely the meanings the framework refuses to merge — nature, cardinality, foreign-key
+ * direction — and a graph that draws every edge as one grey line has lost information the flat table
+ * at least preserved.
+ */
+export declare const Workbench_DomainResource_Schema: z.ZodObject<{
+    workbenchDomainResourceId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+    resourceType: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
+    moduleId: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+    moduleKind: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+    subDomain: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+    fields: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodObject<{
+        fieldName: z.ZodString;
+        specDecorator: z.ZodNullable<z.ZodString>;
+        params: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        derived: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        origin: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    operations: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodObject<{
+        operationIdentifier: z.ZodString;
+        variantType: z.ZodNullable<z.ZodString>;
+        variantKey: z.ZodNullable<z.ZodString>;
+        resourceOperationLike: z.ZodNullable<z.ZodString>;
+        isDefault: z.ZodBoolean;
+        roles: z.ZodArray<z.ZodString>;
+        riskLevel: z.ZodNullable<z.ZodString>;
+        isUnimplemented: z.ZodBoolean;
+        isDisabled: z.ZodBoolean;
+        requiresStepUpAuthentication: z.ZodBoolean;
+        admitsCrossTenantPlatformAdministration: z.ZodBoolean;
+        auditableEventType: z.ZodNullable<z.ZodString>;
+        isMcpExposed: z.ZodBoolean;
+        requiredFeatures: z.ZodArray<z.ZodString>;
+        attributes: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        specification: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        view: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    viewRefs: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodString>>;
+    advanced: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    specification: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodObject<{
+        purpose: z.ZodString;
+        businessRole: z.ZodString;
+        lifecycleRole: z.ZodNullable<z.ZodString>;
+        businessConstraints: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>>;
+    relationships: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodObject<{
+        relationshipId: z.ZodString;
+        resourceType1: z.ZodString;
+        resourceType2: z.ZodString;
+        cardinality1: z.ZodString;
+        cardinality2: z.ZodString;
+        nature: z.ZodString;
+        foreignKeyField: z.ZodNullable<z.ZodString>;
+        foreignKeyHolderResourceType: z.ZodString;
+        jointResourceType: z.ZodNullable<z.ZodString>;
+        isPrimaryScope: z.ZodBoolean;
+        isDisabled: z.ZodBoolean;
+        accessScopeStrategy: z.ZodNullable<z.ZodString>;
+        parentResourceRequirement: z.ZodNullable<z.ZodString>;
+        primaryScope: z.ZodNullable<z.ZodString>;
+        allowCycle: z.ZodBoolean;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type Workbench_DomainResource = z.infer<typeof Workbench_DomainResource_Schema>;
+/**
+ * ONE FIELD of a domain resource — named so a consumer can hold one without re-deriving its type.
  *
- * `resolvedSemantics` is deliberately ABSENT. It is a deep nested object (handling modes, foreign-key
- * persistence) that no current view reads, and copying it into the schema would freeze a shape whose
- * consumer does not exist yet.
+ * Indexed off the row rather than declared separately, because the schema is the one authority for
+ * the shape and a second declaration is a second thing that can drift from it.
  */
-export declare const Workbench_ResourceRelationship_Schema: z.ZodObject<{
-    workbenchResourceRelationshipId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    resourceType1: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    resourceType2: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    cardinality1: z.ZodString;
-    cardinality2: z.ZodString;
-    nature: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    foreignKeyField: z.ZodString;
-    accessScopeStrategy: z.ZodString;
-    parentResourceRequirement: z.ZodString;
-    isPrimaryScope: z.ZodBoolean;
-    allowCycle: z.ZodBoolean;
-    isDisabled: z.ZodBoolean;
-    primaryScope: z.ZodOptional<z.ZodString>;
+export type Workbench_DomainResourceField = Workbench_DomainResource['fields'][number];
+/** ONE OPERATION of a domain resource — indexed off the row, for the same reason. */
+export type Workbench_DomainResourceOperation = Workbench_DomainResource['operations'][number];
+/**
+ * The QUESTION a specification family answers — the axis the workbench groups them by.
+ *
+ * ## Why the families are grouped at all
+ *
+ * Fifteen rows in one undifferentiated list is a directory, not a review surface. A creator opening
+ * the workbench is not looking for "the `document-release-policy` family"; they are looking for what
+ * was decided about who this product is for, or about what it must promise. Grouping by the question
+ * answered is what makes the list navigable without inventing twelve destinations.
+ *
+ * ## Why this is a display vocabulary and not a property of the family
+ *
+ * `ApplicationSpecificationFamilySemanticSchemaRef` names what a family MEANS and what validates it.
+ * Nothing in the runtime branches on the concern below — it exists so a reader can find a row. Adding
+ * it to the semantic authority would put a workbench presentation choice inside the contract the
+ * journey lands artifacts against.
+ *
+ * The family → concern mapping deliberately lives with the projection that derives it (the
+ * companion's `specification-artifacts` behavior), beside the semantic authority it must stay
+ * exhaustive over, rather than here where the authority is not reachable.
+ */
+export declare enum WorkbenchSpecificationArtifactConcern {
+    /** Why the product exists and who it is for — `vision-brief`, `market-snapshot`. */
+    INTENT = "intent",
+    /** What it must do and what it costs — `requirements`, `feature-drafts`, `business-model`. */
+    SCOPE = "scope",
+    /** How and when it gets built — `domain-plan`, `build-plan`, `roadmap`, `placement-plan`. */
+    DELIVERY = "delivery",
+    /** How it presents itself — `brand-brief`. */
+    IDENTITY = "identity",
+    /** What it must promise and publish — the assurance and governed-document families. */
+    OBLIGATIONS = "obligations",
+    /**
+     * A family the workbench has not been taught to group.
+     *
+     * A named member rather than a throw, and rather than silence. The population is derived from the
+     * semantic authority, so a family added there arrives here with no classification — and the two
+     * alternatives are both worse than a visible bucket: refusing the derivation would blank the whole
+     * page over one unmapped row, and defaulting into a real concern would file the new family
+     * somewhere plausible and wrong, which nobody would notice.
+     *
+     * A companion test asserts this member is currently UNUSED, so it stays a signal rather than
+     * becoming a habit.
+     */
+    UNCLASSIFIED = "unclassified"
+}
+/**
+ * Whether a family has landed, and whether what landed still validates.
+ *
+ * THREE states, not two, because "not landed" and "landed but invalid" are the opposite instructions
+ * to a reviewer: the first is work the journey has not done, the second is work it did that no longer
+ * holds. A boolean `isValid` would report both as `false`.
+ */
+export declare enum WorkbenchSpecificationArtifactState {
+    /** The family is exported by the application and its `_core` validator reports no error. */
+    LANDED_VALID = "landed_valid",
+    /** The family is exported and its `_core` validator reports at least one ERROR-severity issue. */
+    LANDED_INVALID = "landed_invalid",
+    /**
+     * The application exports nothing for this family.
+     *
+     * Reported as a ROW rather than omitted — the same call `definition-specifications.behavior.ts`
+     * makes for the same reason: *"an omitted row and a family that does not exist would look the same
+     * to the reader."* On a fresh application an empty list would say nothing; fifteen NOT_LANDED rows
+     * say what the journey has left to produce.
+     */
+    NOT_LANDED = "not_landed"
+}
+/**
+ * ONE application-specification family, projected for a human reviewer.
+ *
+ * ## Why the prose fields are markdown strings
+ *
+ * `StringDisplayMode.MARKDOWN` renders GFM through the framework's own display chrome, which is what
+ * lets headings, lists and paragraphs survive into the page. The alternative — modelling each
+ * family's shape as nested schema fields — would have to be done fifteen times, would freeze twelve
+ * `_core` contracts into this projection, and would still render as a form rather than as a document.
+ *
+ * The rendering is an OUTLINE, never a table. That is the acceptance criterion this resource exists
+ * to satisfy: these artifacts are prose-heavy and their value is in the rationale, so a projection
+ * that put them in columns would destroy exactly what makes them worth reviewing.
+ *
+ * ## Why the heavy fields are NOT summary fields
+ *
+ * `document`, `issues`, `decisionRecord` and `diagram` are excluded from the summary by omission, so
+ * a list carries the INDEX while a detail page carries the documents. One derivation still computes
+ * all of them either way — this bounds the RESPONSE, not the work.
+ *
+ * Which variant a caller gets matters, and is easy to state wrongly: the LIST operation's DEFAULT
+ * variant answers the full row, and it is the operation's `summary` variant that applies this
+ * projection. Measured against the live wonder-crm companion, 2026-08-31:
+ * `GET /api/v1/workbench-specification-artifacts` → **149,089 B**, and
+ * `…/workbench-specification-artifacts/summary` → **3,654 B** carrying the eight fields marked
+ * below. A list layout renders the summary variant — which is also why the addressing field must be
+ * marked, or every row in that list is unclickable.
+ */
+export declare const Workbench_SpecificationArtifact_Schema: z.ZodObject<{
+    family: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+    title: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
+    description: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
+    contentSummary: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNullable<z.ZodString>>;
+    concern: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof WorkbenchSpecificationArtifactConcern>>;
+    state: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof WorkbenchSpecificationArtifactState>>;
+    schemaRef: z.ZodString;
+    sourcePath: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNullable<z.ZodString>>;
+    errorCount: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNumber>;
+    warnCount: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNumber>;
+    producedByPlaybookRefs: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodString>>;
+    content: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    document: z.ZodNullable<z.ZodString>;
+    issues: z.ZodNullable<z.ZodString>;
+    decisionRecord: z.ZodNullable<z.ZodString>;
+    diagram: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;
-export type Workbench_ResourceRelationship = z.infer<typeof Workbench_ResourceRelationship_Schema>;
+export type Workbench_SpecificationArtifact = z.infer<typeof Workbench_SpecificationArtifact_Schema>;
 //# sourceMappingURL=workbench-resources.custom.shared.schemas.d.ts.map

package/dist/esm/workbench/workbench-resources.custom.shared.schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"workbench-resources.custom.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/workbench/workbench-resources.custom.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,kCAAkC;;;;;;;;iBAmC7C,CAAC;AAEH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAC;AAE7F;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;iBAiChD,CAAC;AAEH,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qCAAqC,CAAC,CAAC"}
+{"version":3,"file":"workbench-resources.custom.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/workbench/workbench-resources.custom.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,2CAA2C;;;;;;;;;;;;;;;;iBA+DtD,CAAC;AAEH,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2CAA2C,CAAC,CAAC;AAE/G;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgL1C,CAAC;AAEH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAEvF;;;;;GAKG;AACH,MAAM,MAAM,6BAA6B,GAAG,wBAAwB,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC;AAEvF,qFAAqF;AACrF,MAAM,MAAM,iCAAiC,GAAG,wBAAwB,CAAC,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC;AAE/F;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,oBAAY,qCAAqC;IAC/C,oFAAoF;IACpF,MAAM,WAAW;IACjB,8FAA8F;IAC9F,KAAK,UAAU;IACf,6FAA6F;IAC7F,QAAQ,aAAa;IACrB,8CAA8C;IAC9C,QAAQ,aAAa;IACrB,uFAAuF;IACvF,WAAW,gBAAgB;IAC3B;;;;;;;;;;;OAWG;IACH,YAAY,iBAAiB;CAC9B;AAED;;;;;;GAMG;AACH,oBAAY,mCAAmC;IAC7C,4FAA4F;IAC5F,YAAY,iBAAiB;IAC7B,kGAAkG;IAClG,cAAc,mBAAmB;IACjC;;;;;;;OAOG;IACH,UAAU,eAAe;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;iBAoHjD,CAAC;AAEH,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sCAAsC,CAAC,CAAC"}