npm - @wildo-ai/platform-core-shared - Versions diffs - 1.1.10 → 1.1.12 - Mend

@wildo-ai/platform-core-shared 1.1.10 → 1.1.12

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (142) hide show

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

	@@ -1 +1 @@
1	- {"version":3,"file":"workbench-resources.custom.shared.resources-config.schemas.d.ts","sourceRoot":"","sources":["../../../src/workbench/workbench-resources.custom.shared.resources-config.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,qBAAqB,EAIrB,0BAA0B,EAC1B,4BAA4B,EAC5B,oBAAoB,EAMrB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;~~AAUxB~~,OAAO,EAGL,qCAAqC,EACrC,mCAAmC,EACpC,MAAM,6CAA6C,CAAC;AAMrD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,yCAAyC,OAAO,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,wBAAwB;;;;;EA6BvC;AAED;;;;;;GAMG;AACH,wBAAgB,4BAA4B;;;;;;EAK3C;AAGD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,sCAAsC,EAAE,oBAAoB,EA2CxE,CAAC;AAsBF,KAAK,sCAAsC,GACvC,qBAAqB,CAAC,IAAI,GAC1B,qBAAqB,CAAC,IAAI,CAAC;AAE/B,eAAO,MAAM,oEAAoE,GAC9E,wBAAwB,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkC7C,CAAC;AAiCL,KAAK,6CAA6C,GAC9C,qBAAqB,CAAC,IAAI,GAC1B,qBAAqB,CAAC,IAAI,CAAC;AAE/B,eAAO,MAAM,2EAA2E,GACrF,wBAAwB,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;;kBA+C7C,CAAC;AAEL,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uDAzHnC,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAwEtB,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;;;CA0DhD,CAAC"}
1	+ {"version":3,"file":"workbench-resources.custom.shared.resources-config.schemas.d.ts","sourceRoot":"","sources":["../../../src/workbench/workbench-resources.custom.shared.resources-config.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,qBAAqB,EAIrB,0BAA0B,EAC1B,4BAA4B,EAC5B,oBAAoB,EAMrB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,0BAA0B,CAAC;AAUlC,OAAO,EAGL,qCAAqC,EACrC,mCAAmC,EACpC,MAAM,6CAA6C,CAAC;AAMrD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,yCAAyC,OAAO,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,wBAAwB;;;;;EA6BvC;AAED;;;;;;GAMG;AACH,wBAAgB,4BAA4B;;;;;;EAK3C;AAGD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,sCAAsC,EAAE,oBAAoB,EA2CxE,CAAC;AAsBF,KAAK,sCAAsC,GACvC,qBAAqB,CAAC,IAAI,GAC1B,qBAAqB,CAAC,IAAI,CAAC;AAE/B,eAAO,MAAM,oEAAoE,GAC9E,wBAAwB,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkC7C,CAAC;AAiCL,KAAK,6CAA6C,GAC9C,qBAAqB,CAAC,IAAI,GAC1B,qBAAqB,CAAC,IAAI,CAAC;AAE/B,eAAO,MAAM,2EAA2E,GACrF,wBAAwB,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;;kBA+C7C,CAAC;AAEL,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uDAzHnC,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAwEtB,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;;;CA0DhD,CAAC"}

package/dist/esm/workbench/workbench-resources.custom.shared.resources-config.schemas.js CHANGED Viewed

@@ -1,5 +1,6 @@
 import { CORE_APP_ROLES, CoreResourceOperation, CoreResourceType, IntrospectionTenancyStance, PersistenceAdapter, ResourceOperationRiskLevel, ResourceOperationVariantType, ResourceRelationshipAccessScopeStrategy, ResourceRelationshipCardinality, RelationshipNature, createResourceConfiguration_Initialization, createResourcesRelationship, } from '@wildo-ai/saas-models';
 import { z } from 'zod';
+import '@wildo-ai/zod-decorators';
 import { WorkbenchShared_ResourceFieldIdentifier, WorkbenchShared_ResourceType, } from './workbench-resources-types.custom.shared.schemas.js';
 import { buildWorkbenchAspectRelationships, workbenchAspectResources_ConfigurationsFactoryMap, } from './workbench-aspect-resources.custom.shared.schemas.js';
 import { Workbench_DomainResource_Schema, Workbench_SpecificationArtifact_Schema, WorkbenchSpecificationArtifactConcern, WorkbenchSpecificationArtifactState, } from './workbench-resources.custom.shared.schemas.js';

package/dist/esm/workbench/workbench-resources.custom.shared.resources-config.schemas.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"workbench-resources.custom.shared.resources-config.schemas.js","sourceRoot":"","sources":["../../../../src/workbench/workbench-resources.custom.shared.resources-config.schemas.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n CORE_APP_ROLES,\n CoreResourceOperation,\n CoreResourceType,\n IntrospectionTenancyStance,\n PersistenceAdapter,\n ResourceOperationRiskLevel,\n ResourceOperationVariantType,\n ResourceRelationship,\n ResourceRelationshipAccessScopeStrategy,\n ResourceRelationshipCardinality,\n RelationshipNature,\n createResourceConfiguration_Initialization,\n createResourcesRelationship,\n} from '@wildo-ai/saas-models';\n\nimport { z } from 'zod';\n\nimport {\n WorkbenchShared_ResourceFieldIdentifier,\n WorkbenchShared_ResourceType,\n} from './workbench-resources-types.custom.shared.schemas';\nimport {\n buildWorkbenchAspectRelationships,\n workbenchAspectResources_ConfigurationsFactoryMap,\n} from './workbench-aspect-resources.custom.shared.schemas';\nimport {\n Workbench_DomainResource_Schema,\n Workbench_SpecificationArtifact_Schema,\n WorkbenchSpecificationArtifactConcern,\n WorkbenchSpecificationArtifactState,\n} from './workbench-resources.custom.shared.schemas';\nimport {\n workbenchCreationPlane_ResourcesConfigurationsFactoryMap,\n workbenchCreationPlane_ResourcesRelationships,\n} from './workbench-creation-plane.custom.shared.resources-config.schemas';\n\n/*\n The page ceiling every workbench LIST declares — and it is a correctness fix, not a tuning knob.\n \n `IntrospectionResourceRepository.list()` answers `pagination.limit = rows.length` over the WHOLE\n * derived set, deliberately: a behavior computes its entire answer in one subprocess run, there is no\n * cursor to seek, and reporting a total the caller cannot page past would be a lie. The response DTO\n * then bounds that `limit` by the operation's `maxPaginatedResultPerPageLimit`, whose default is\n * 100. So any introspected resource whose derivation exceeds 100 rows fails with `too_big` at\n * `pagination.limit` — the request having been served correctly right up to the last hop.\n \n Measured 2026-08-31, and the measurement is why this ceiling is a CORRECTNESS FIX rather than\n * headroom. The domain model projects every resource the observed application RUNS, which is its own\n * plus the engine's whole merged vocabulary: `saas-models`' core map alone carries 82 resources\n * and 105 relationships before `saas-backend-lib`'s map or the application's own eight are\n * counted. So the domain-model LIST is already comfortably past the default 100 on the smallest\n * application there is, and would have failed with `too_big` at `pagination.limit` — the request\n * having been served correctly right up to the last hop, and the bound named in none of these\n * declarations. The number also scales with the OBSERVED application, which is the one input this\n * repository does not control.\n \n Declared on the shared variant so every workbench resource is bounded by the same number, rather\n * than one being raised and its siblings left waiting to hit the same wall.\n \n Above the ceiling the request FAILS rather than truncating, which is the correct direction: a\n * silently short domain model is indistinguishable from a complete one once it is drawn.\n /\nexport const WORKBENCH_INTROSPECTION_MAX_ROWS_PER_PAGE = 1000;\n\n/\n Read-only over HTTP, and PUBLIC.\n \n `APP_PUBLIC` means what its enum comment says — accessible to everyone, no credential — and as of\n * 2026-08-30 the runtime implements it: the authentication chain now admits an operation declaring\n * this role instead of demanding a credential it never required. Before that it was declared,\n * published as public by the OpenAPI generator, and refused at runtime.\n \n ## Why these rows are genuinely public\n \n They are a projection of the application's OWN SOURCE — module ids and the resource types each\n * registers — carrying no tenant dimension, which is exactly what the binding's\n * `APPLICATION_STRUCTURE` tenancy stance declares. There is no subject whose data could leak,\n * because no subject's data is here.\n \n This is the same category as a public price list, a frontend application configuration or an i18n\n * bundle: things every caller may read, which until now could only be served by escaping the\n * resource system into a manual controller.\n \n ## What still confines them\n \n The companion asserts a loopback bind at startup and fails closed otherwise, so this surface is\n * reachable only from the developer's own machine. `APP_PUBLIC` is the right declaration on its\n * merits; the loopback bind is what makes the whole workbench local, and both remain true\n * independently.\n \n If an introspected resource is ever added that projects something OTHER than the application's own\n * structure, this role is wrong for it — the stance and the role must move together.\n /\nexport function createReadOnlyApiVariant() {\n return {\n variantType: ResourceOperationVariantType.API_CALL as const,\n isDefault: true as const,\n /\n * `APP_PUBLIC` ALONE, and that single entry is now load-bearing evidence rather than a shorthand.\n \n It briefly read `[APP_PUBLIC, APP_USER]`. That was a WORKAROUND for an engine defect (#153),\n * not a statement about these rows: the authorizer admitted a public operation only when the\n * caller was ALSO a public execution, so an AUTHENTICATED caller fell past that carve-out to the\n * ordinary role gate — where `APP_PUBLIC` is in nobody's granted set — and was refused. Measured\n * 2026-08-31 on the workbench's module projection (a resource retired the same day): with no\n * credential the LIST answered 200 with the eight modules; with a valid administrator bearer it\n * answered 403 `authorizations_access_denied`. The workbench's own sidebar could not read the\n * rows it exists to show, because its operator had logged in.\n \n `requiredRolesDeclarePublicAccess` in `@wildo-ai/saas-models` is now the one named source for\n * what `APP_PUBLIC` means, and every role gate in the engine consults it — so the sentinel\n * genuinely admits every caller and the second role has nothing left to add. Declaring it anyway\n * would say these rows need an authenticated reader, which is the opposite of what they are.\n \n Keeping the bare declaration is deliberate: it is the surface the fix is exercised on. If the\n * defect ever returns, the workbench sidebar goes blank for a logged-in operator — a loud,\n * immediate signal — instead of being silently masked by a role that was only ever there to hide\n * it.\n /\n roles: [CORE_APP_ROLES.APP_PUBLIC],\n riskLevel: ResourceOperationRiskLevel.LOW as const,\n };\n}\n\n/\n The LIST variant — the read-only variant plus the page ceiling.\n \n Separate from {@link createReadOnlyApiVariant} because `maxPaginatedResultPerPageLimit` is only\n * read on a LIST-like operation (`isListLike` in the resource factory); putting it on READ too would\n * declare a field that operation does not have, which reads as though it did something.\n /\nexport function createReadOnlyListApiVariant() {\n return {\n ...createReadOnlyApiVariant(),\n maxPaginatedResultPerPageLimit: WORKBENCH_INTROSPECTION_MAX_ROWS_PER_PAGE,\n };\n}\n\n\n/\n APPLICATION-scoped, anchored by a STANDALONE relationship.\n \n The form the resource factory's own migration note prescribes: STANDALONE \"keeps the rel inert for\n * URL routing while declaring the structural ownership anchor\", so the resource is reachable at a\n * flat path rather than nested under `/applications/:id/`.\n \n APPLICATION rather than ORGANIZATIONS on purpose: these rows describe the application's own\n * structure, so the application IS their scope. There is no tenant dimension to anchor on — the\n * binding's `APPLICATION_STRUCTURE` stance above says the same thing from the data's side.\n \n This originally read as a consequence of API-key scoping, because the workbench browser was\n * expected to authenticate with an application-scope key. `APP_PUBLIC` removed that requirement\n * entirely (see the role note above), so the scope now rests on its own merits rather than on a\n * credential's constraint. The tenant-scoping trade remains recorded in issue #118.\n /\nexport const workbenchShared_ResourcesRelationships: ResourceRelationship[] = [\n /\n * A STANDALONE anchor for the domain-model resource. Every INTROSPECTION resource needs one:\n * `resourcePrimaryScope` is DERIVED from a relationship flagged `isPrimaryScope`, so a resource\n * without one has no scope at all — and STANDALONE keeps it off the URL, which is what gives these\n * resources a flat route instead of `/applications/:id/...`.\n /\n createResourcesRelationship(\n CoreResourceType.APPLICATION,\n WorkbenchShared_ResourceType.DOMAIN_RESOURCES,\n ResourceRelationshipCardinality.ONE,\n ResourceRelationshipCardinality.MANY,\n {\n nature: RelationshipNature.COMPOSITION,\n isPrimaryScope: true,\n accessScopeStrategy: ResourceRelationshipAccessScopeStrategy.STANDALONE,\n contextPolicy: {},\n },\n ),\n / And for the specification-artifacts resource. Same anchor, same reason. /\n createResourcesRelationship(\n CoreResourceType.APPLICATION,\n WorkbenchShared_ResourceType.SPECIFICATION_ARTIFACTS,\n ResourceRelationshipCardinality.ONE,\n ResourceRelationshipCardinality.MANY,\n {\n nature: RelationshipNature.COMPOSITION,\n isPrimaryScope: true,\n accessScopeStrategy: ResourceRelationshipAccessScopeStrategy.STANDALONE,\n contextPolicy: {},\n },\n ),\n /\n * Every family-aspect resource's relationships — the same STANDALONE anchor per aspect, plus\n * one REFERENCE per declared edge whose `foreignKeyField` is what makes reference navigation\n * resolve. Generated from the descriptor table beside the aspect configs.\n /\n ...buildWorkbenchAspectRelationships(),\n /\n * The creation plane's four STANDALONE anchors — same form, declared beside its configs. Merged\n * here so the one array every registrar consumes stays the single relationship authority.\n /\n ...workbenchCreationPlane_ResourcesRelationships,\n];\n\n\n/\n The observed application's domain model — one row per resource, and the source the workbench's\n * domain-model graph is drawn from.\n \n ## Why a THIRD introspected resource beside modules and relationships\n \n Its two siblings project two DIFFERENT behaviors on two different targets, so a graph assembled\n * from both is assembled from two subprocess runs against a working tree an operator is editing —\n * nodes from one state of the application, edges from the next, with nothing to detect the mismatch.\n * `application-domain-model` answers ownership, edges, field names and specification prose from a\n * SINGLE import, which is the only shape in which the three are internally consistent. Speed is the\n * smaller half of the reason; consistency is the whole of it.\n \n Same tenancy stance and same PUBLIC role as its siblings, for the same reason: a resource, the\n * module that registers it and the edges it declares are facts about the application's SOURCE, with\n * no tenant dimension and no subject whose data could leak.\n /\nconst WorkbenchDomainResource_Operations = undefined;\n\ntype WorkbenchDomainResource_CoreOperations =\n \| CoreResourceOperation.READ\n \| CoreResourceOperation.LIST;\n\nexport const workbenchDomainResources_ResourceConfiguration_InitializationFactory =\n (resourcesRelationships: ResourceRelationship[]) => createResourceConfiguration_Initialization<\n typeof WorkbenchDomainResource_Operations,\n WorkbenchDomainResource_CoreOperations,\n typeof Workbench_DomainResource_Schema\n >({\n mainSchema: Workbench_DomainResource_Schema,\n resourceIdentifier: WorkbenchShared_ResourceType.DOMAIN_RESOURCES,\n resourceFieldIdentifier:\n WorkbenchShared_ResourceFieldIdentifier[WorkbenchShared_ResourceType.DOMAIN_RESOURCES],\n resourceRelationships: resourcesRelationships,\n isSystemResource: false,\n persistenceAdapter: PersistenceAdapter.INTROSPECTION,\n introspectionBinding: {\n behavior: 'application-domain-model',\n rowsPath: 'domainResources',\n tenancy: IntrospectionTenancyStance.APPLICATION_STRUCTURE,\n /\n * A resource type is unique in a registry by construction — a registry is keyed by it — so one\n * field is the whole key here, and no discriminator can be needed.\n \n Composed onto `workbenchDomainResourceId` rather than addressing the row by `resourceType`\n * directly: `resourceFieldIdentifier` values are published into the GLOBAL field-identifier map\n * that resolves a foreign-key field NAME to the resource it points at, and `resourceType` is a\n * name any application could collide with on a map whose whole job is that names are\n * unambiguous.\n /\n identityFields: ['resourceType'],\n },\n coreOperations: [CoreResourceOperation.READ, CoreResourceOperation.LIST],\n customOperation: WorkbenchDomainResource_Operations,\n operationsConfiguration: {\n [CoreResourceOperation.READ]: { variants: [createReadOnlyApiVariant()] },\n [CoreResourceOperation.LIST]: { variants: [createReadOnlyListApiVariant()] },\n },\n });\n\n/\n Every application-specification family the journey produces, projected for a human reviewer.\n \n ## What this is for\n \n Its three siblings project the application's STRUCTURE. This one projects the PRODUCT and its\n * obligations — vision, market, requirements, roadmap, brand, business model, the assurance\n * programme and the governed-document families — which until now were reachable only by opening a\n * TypeScript file in an editor (issue #162).\n \n ## Why the same behavior does not serve it\n \n `application-domain-model` answers questions about the resource registry. A family's content is\n * not in the registry at all: it is on the specifications package's companion exports, validated by\n * the `_core` validator the semantic authority names for it. Different target, different question,\n * different behavior — the split the two original workbench resources already demonstrate.\n \n ## Same posture as its siblings, for the same reason\n \n `APPLICATION_STRUCTURE` tenancy and `APP_PUBLIC`: a vision brief, a roadmap and a compliance\n * programme are facts about what the application's own source SAYS about itself. There is no tenant\n * dimension and no subject whose data could leak, and the companion's loopback bind is what keeps\n * the whole workbench local.\n \n READ and LIST only, and structurally so — `PersistenceAdapter.INTROSPECTION` refuses every write\n * verb, rows are derived per read and nothing is stored. Acceptance of a specification is a human\n * git commit (`.claude/rules/one-source-of-truth.md` rule 2), so there is deliberately no place here\n * for an acceptance state to accumulate, not even by accident.\n /\nconst WorkbenchSpecificationArtifact_Operations = undefined;\n\ntype WorkbenchSpecificationArtifact_CoreOperations =\n \| CoreResourceOperation.READ\n \| CoreResourceOperation.LIST;\n\nexport const workbenchSpecificationArtifacts_ResourceConfiguration_InitializationFactory =\n (resourcesRelationships: ResourceRelationship[]) => createResourceConfiguration_Initialization<\n typeof WorkbenchSpecificationArtifact_Operations,\n WorkbenchSpecificationArtifact_CoreOperations,\n typeof Workbench_SpecificationArtifact_Schema\n >({\n mainSchema: Workbench_SpecificationArtifact_Schema,\n resourceIdentifier: WorkbenchShared_ResourceType.SPECIFICATION_ARTIFACTS,\n resourceFieldIdentifier:\n WorkbenchShared_ResourceFieldIdentifier[WorkbenchShared_ResourceType.SPECIFICATION_ARTIFACTS],\n resourceRelationships: resourcesRelationships,\n isSystemResource: false,\n persistenceAdapter: PersistenceAdapter.INTROSPECTION,\n introspectionBinding: {\n behavior: 'specification-artifacts',\n rowsPath: 'artifacts',\n tenancy: IntrospectionTenancyStance.APPLICATION_STRUCTURE,\n /\n * NO `identityFields`, and the omission is the point.\n \n Every row already carries `family`, and `family` IS this resource's\n * `resourceFieldIdentifier` — so there is nothing to compose. This is the `moduleId` case, not\n * the relationships one: declaring an identity here would stamp a composed key over a real\n * field, replacing the source's own id with a copy of itself.\n /\n },\n coreOperations: [CoreResourceOperation.READ, CoreResourceOperation.LIST],\n customOperation: WorkbenchSpecificationArtifact_Operations,\n operationsConfiguration: {\n [CoreResourceOperation.READ]: { variants: [createReadOnlyApiVariant()] },\n [CoreResourceOperation.LIST]: {\n variants: [{\n ...createReadOnlyListApiVariant(),\n /\n * The two review axes a reader slices fifteen rows by. Declaring them is an OBLIGATION,\n * not a hint: the introspection source honors exactly the scalar-equality/IN filters that\n * reach it and REFUSES shapes it cannot apply, because a declared filter that is silently\n * dropped returns the unfiltered set wearing a filtered label — the `--state ready` defect\n * class. The frontend's concern quick-filter tabs require `concern` to be here, or the\n * tab strip silently never renders.\n */\n filterFields: {\n concern: z.enum(WorkbenchSpecificationArtifactConcern).systemEnum('WorkbenchSpecificationArtifactConcern'),\n state: z.enum(WorkbenchSpecificationArtifactState).systemEnum('WorkbenchSpecificationArtifactState'),\n },\n }],\n },\n },\n });\n\nexport const workbenchShared_ResourcesConfigurationsFactoryMap = {\n [WorkbenchShared_ResourceType.DOMAIN_RESOURCES]:\n workbenchDomainResources_ResourceConfiguration_InitializationFactory,\n [WorkbenchShared_ResourceType.SPECIFICATION_ARTIFACTS]:\n workbenchSpecificationArtifacts_ResourceConfiguration_InitializationFactory,\n // The 40 family-aspect resources — generated from the descriptor table, one mold for all.\n ...workbenchAspectResources_ConfigurationsFactoryMap,\n // The creation plane — companion-RUNTIME projections (authenticated, APPLICATION_RUNTIME tenancy).\n ...workbenchCreationPlane_ResourcesConfigurationsFactoryMap,\n};\n"]}
1	+ {"version":3,"file":"workbench-resources.custom.shared.resources-config.schemas.js","sourceRoot":"","sources":["../../../src/workbench/workbench-resources.custom.shared.resources-config.schemas.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n CORE_APP_ROLES,\n CoreResourceOperation,\n CoreResourceType,\n IntrospectionTenancyStance,\n PersistenceAdapter,\n ResourceOperationRiskLevel,\n ResourceOperationVariantType,\n ResourceRelationship,\n ResourceRelationshipAccessScopeStrategy,\n ResourceRelationshipCardinality,\n RelationshipNature,\n createResourceConfiguration_Initialization,\n createResourcesRelationship,\n} from '@wildo-ai/saas-models';\n\nimport { z } from 'zod';\nimport '@wildo-ai/zod-decorators';\n\nimport {\n WorkbenchShared_ResourceFieldIdentifier,\n WorkbenchShared_ResourceType,\n} from './workbench-resources-types.custom.shared.schemas';\nimport {\n buildWorkbenchAspectRelationships,\n workbenchAspectResources_ConfigurationsFactoryMap,\n} from './workbench-aspect-resources.custom.shared.schemas';\nimport {\n Workbench_DomainResource_Schema,\n Workbench_SpecificationArtifact_Schema,\n WorkbenchSpecificationArtifactConcern,\n WorkbenchSpecificationArtifactState,\n} from './workbench-resources.custom.shared.schemas';\nimport {\n workbenchCreationPlane_ResourcesConfigurationsFactoryMap,\n workbenchCreationPlane_ResourcesRelationships,\n} from './workbench-creation-plane.custom.shared.resources-config.schemas';\n\n/*\n The page ceiling every workbench LIST declares — and it is a correctness fix, not a tuning knob.\n \n `IntrospectionResourceRepository.list()` answers `pagination.limit = rows.length` over the WHOLE\n * derived set, deliberately: a behavior computes its entire answer in one subprocess run, there is no\n * cursor to seek, and reporting a total the caller cannot page past would be a lie. The response DTO\n * then bounds that `limit` by the operation's `maxPaginatedResultPerPageLimit`, whose default is\n * 100. So any introspected resource whose derivation exceeds 100 rows fails with `too_big` at\n * `pagination.limit` — the request having been served correctly right up to the last hop.\n \n Measured 2026-08-31, and the measurement is why this ceiling is a CORRECTNESS FIX rather than\n * headroom. The domain model projects every resource the observed application RUNS, which is its own\n * plus the engine's whole merged vocabulary: `saas-models`' core map alone carries 82 resources\n * and 105 relationships before `saas-backend-lib`'s map or the application's own eight are\n * counted. So the domain-model LIST is already comfortably past the default 100 on the smallest\n * application there is, and would have failed with `too_big` at `pagination.limit` — the request\n * having been served correctly right up to the last hop, and the bound named in none of these\n * declarations. The number also scales with the OBSERVED application, which is the one input this\n * repository does not control.\n \n Declared on the shared variant so every workbench resource is bounded by the same number, rather\n * than one being raised and its siblings left waiting to hit the same wall.\n \n Above the ceiling the request FAILS rather than truncating, which is the correct direction: a\n * silently short domain model is indistinguishable from a complete one once it is drawn.\n /\nexport const WORKBENCH_INTROSPECTION_MAX_ROWS_PER_PAGE = 1000;\n\n/\n Read-only over HTTP, and PUBLIC.\n \n `APP_PUBLIC` means what its enum comment says — accessible to everyone, no credential — and as of\n * 2026-08-30 the runtime implements it: the authentication chain now admits an operation declaring\n * this role instead of demanding a credential it never required. Before that it was declared,\n * published as public by the OpenAPI generator, and refused at runtime.\n \n ## Why these rows are genuinely public\n \n They are a projection of the application's OWN SOURCE — module ids and the resource types each\n * registers — carrying no tenant dimension, which is exactly what the binding's\n * `APPLICATION_STRUCTURE` tenancy stance declares. There is no subject whose data could leak,\n * because no subject's data is here.\n \n This is the same category as a public price list, a frontend application configuration or an i18n\n * bundle: things every caller may read, which until now could only be served by escaping the\n * resource system into a manual controller.\n \n ## What still confines them\n \n The companion asserts a loopback bind at startup and fails closed otherwise, so this surface is\n * reachable only from the developer's own machine. `APP_PUBLIC` is the right declaration on its\n * merits; the loopback bind is what makes the whole workbench local, and both remain true\n * independently.\n \n If an introspected resource is ever added that projects something OTHER than the application's own\n * structure, this role is wrong for it — the stance and the role must move together.\n /\nexport function createReadOnlyApiVariant() {\n return {\n variantType: ResourceOperationVariantType.API_CALL as const,\n isDefault: true as const,\n /\n * `APP_PUBLIC` ALONE, and that single entry is now load-bearing evidence rather than a shorthand.\n \n It briefly read `[APP_PUBLIC, APP_USER]`. That was a WORKAROUND for an engine defect (#153),\n * not a statement about these rows: the authorizer admitted a public operation only when the\n * caller was ALSO a public execution, so an AUTHENTICATED caller fell past that carve-out to the\n * ordinary role gate — where `APP_PUBLIC` is in nobody's granted set — and was refused. Measured\n * 2026-08-31 on the workbench's module projection (a resource retired the same day): with no\n * credential the LIST answered 200 with the eight modules; with a valid administrator bearer it\n * answered 403 `authorizations_access_denied`. The workbench's own sidebar could not read the\n * rows it exists to show, because its operator had logged in.\n \n `requiredRolesDeclarePublicAccess` in `@wildo-ai/saas-models` is now the one named source for\n * what `APP_PUBLIC` means, and every role gate in the engine consults it — so the sentinel\n * genuinely admits every caller and the second role has nothing left to add. Declaring it anyway\n * would say these rows need an authenticated reader, which is the opposite of what they are.\n \n Keeping the bare declaration is deliberate: it is the surface the fix is exercised on. If the\n * defect ever returns, the workbench sidebar goes blank for a logged-in operator — a loud,\n * immediate signal — instead of being silently masked by a role that was only ever there to hide\n * it.\n /\n roles: [CORE_APP_ROLES.APP_PUBLIC],\n riskLevel: ResourceOperationRiskLevel.LOW as const,\n };\n}\n\n/\n The LIST variant — the read-only variant plus the page ceiling.\n \n Separate from {@link createReadOnlyApiVariant} because `maxPaginatedResultPerPageLimit` is only\n * read on a LIST-like operation (`isListLike` in the resource factory); putting it on READ too would\n * declare a field that operation does not have, which reads as though it did something.\n /\nexport function createReadOnlyListApiVariant() {\n return {\n ...createReadOnlyApiVariant(),\n maxPaginatedResultPerPageLimit: WORKBENCH_INTROSPECTION_MAX_ROWS_PER_PAGE,\n };\n}\n\n\n/\n APPLICATION-scoped, anchored by a STANDALONE relationship.\n \n The form the resource factory's own migration note prescribes: STANDALONE \"keeps the rel inert for\n * URL routing while declaring the structural ownership anchor\", so the resource is reachable at a\n * flat path rather than nested under `/applications/:id/`.\n \n APPLICATION rather than ORGANIZATIONS on purpose: these rows describe the application's own\n * structure, so the application IS their scope. There is no tenant dimension to anchor on — the\n * binding's `APPLICATION_STRUCTURE` stance above says the same thing from the data's side.\n \n This originally read as a consequence of API-key scoping, because the workbench browser was\n * expected to authenticate with an application-scope key. `APP_PUBLIC` removed that requirement\n * entirely (see the role note above), so the scope now rests on its own merits rather than on a\n * credential's constraint. The tenant-scoping trade remains recorded in issue #118.\n /\nexport const workbenchShared_ResourcesRelationships: ResourceRelationship[] = [\n /\n * A STANDALONE anchor for the domain-model resource. Every INTROSPECTION resource needs one:\n * `resourcePrimaryScope` is DERIVED from a relationship flagged `isPrimaryScope`, so a resource\n * without one has no scope at all — and STANDALONE keeps it off the URL, which is what gives these\n * resources a flat route instead of `/applications/:id/...`.\n /\n createResourcesRelationship(\n CoreResourceType.APPLICATION,\n WorkbenchShared_ResourceType.DOMAIN_RESOURCES,\n ResourceRelationshipCardinality.ONE,\n ResourceRelationshipCardinality.MANY,\n {\n nature: RelationshipNature.COMPOSITION,\n isPrimaryScope: true,\n accessScopeStrategy: ResourceRelationshipAccessScopeStrategy.STANDALONE,\n contextPolicy: {},\n },\n ),\n / And for the specification-artifacts resource. Same anchor, same reason. /\n createResourcesRelationship(\n CoreResourceType.APPLICATION,\n WorkbenchShared_ResourceType.SPECIFICATION_ARTIFACTS,\n ResourceRelationshipCardinality.ONE,\n ResourceRelationshipCardinality.MANY,\n {\n nature: RelationshipNature.COMPOSITION,\n isPrimaryScope: true,\n accessScopeStrategy: ResourceRelationshipAccessScopeStrategy.STANDALONE,\n contextPolicy: {},\n },\n ),\n /\n * Every family-aspect resource's relationships — the same STANDALONE anchor per aspect, plus\n * one REFERENCE per declared edge whose `foreignKeyField` is what makes reference navigation\n * resolve. Generated from the descriptor table beside the aspect configs.\n /\n ...buildWorkbenchAspectRelationships(),\n /\n * The creation plane's four STANDALONE anchors — same form, declared beside its configs. Merged\n * here so the one array every registrar consumes stays the single relationship authority.\n /\n ...workbenchCreationPlane_ResourcesRelationships,\n];\n\n\n/\n The observed application's domain model — one row per resource, and the source the workbench's\n * domain-model graph is drawn from.\n \n ## Why a THIRD introspected resource beside modules and relationships\n \n Its two siblings project two DIFFERENT behaviors on two different targets, so a graph assembled\n * from both is assembled from two subprocess runs against a working tree an operator is editing —\n * nodes from one state of the application, edges from the next, with nothing to detect the mismatch.\n * `application-domain-model` answers ownership, edges, field names and specification prose from a\n * SINGLE import, which is the only shape in which the three are internally consistent. Speed is the\n * smaller half of the reason; consistency is the whole of it.\n \n Same tenancy stance and same PUBLIC role as its siblings, for the same reason: a resource, the\n * module that registers it and the edges it declares are facts about the application's SOURCE, with\n * no tenant dimension and no subject whose data could leak.\n /\nconst WorkbenchDomainResource_Operations = undefined;\n\ntype WorkbenchDomainResource_CoreOperations =\n \| CoreResourceOperation.READ\n \| CoreResourceOperation.LIST;\n\nexport const workbenchDomainResources_ResourceConfiguration_InitializationFactory =\n (resourcesRelationships: ResourceRelationship[]) => createResourceConfiguration_Initialization<\n typeof WorkbenchDomainResource_Operations,\n WorkbenchDomainResource_CoreOperations,\n typeof Workbench_DomainResource_Schema\n >({\n mainSchema: Workbench_DomainResource_Schema,\n resourceIdentifier: WorkbenchShared_ResourceType.DOMAIN_RESOURCES,\n resourceFieldIdentifier:\n WorkbenchShared_ResourceFieldIdentifier[WorkbenchShared_ResourceType.DOMAIN_RESOURCES],\n resourceRelationships: resourcesRelationships,\n isSystemResource: false,\n persistenceAdapter: PersistenceAdapter.INTROSPECTION,\n introspectionBinding: {\n behavior: 'application-domain-model',\n rowsPath: 'domainResources',\n tenancy: IntrospectionTenancyStance.APPLICATION_STRUCTURE,\n /\n * A resource type is unique in a registry by construction — a registry is keyed by it — so one\n * field is the whole key here, and no discriminator can be needed.\n \n Composed onto `workbenchDomainResourceId` rather than addressing the row by `resourceType`\n * directly: `resourceFieldIdentifier` values are published into the GLOBAL field-identifier map\n * that resolves a foreign-key field NAME to the resource it points at, and `resourceType` is a\n * name any application could collide with on a map whose whole job is that names are\n * unambiguous.\n /\n identityFields: ['resourceType'],\n },\n coreOperations: [CoreResourceOperation.READ, CoreResourceOperation.LIST],\n customOperation: WorkbenchDomainResource_Operations,\n operationsConfiguration: {\n [CoreResourceOperation.READ]: { variants: [createReadOnlyApiVariant()] },\n [CoreResourceOperation.LIST]: { variants: [createReadOnlyListApiVariant()] },\n },\n });\n\n/\n Every application-specification family the journey produces, projected for a human reviewer.\n \n ## What this is for\n \n Its three siblings project the application's STRUCTURE. This one projects the PRODUCT and its\n * obligations — vision, market, requirements, roadmap, brand, business model, the assurance\n * programme and the governed-document families — which until now were reachable only by opening a\n * TypeScript file in an editor (issue #162).\n \n ## Why the same behavior does not serve it\n \n `application-domain-model` answers questions about the resource registry. A family's content is\n * not in the registry at all: it is on the specifications package's companion exports, validated by\n * the `_core` validator the semantic authority names for it. Different target, different question,\n * different behavior — the split the two original workbench resources already demonstrate.\n \n ## Same posture as its siblings, for the same reason\n \n `APPLICATION_STRUCTURE` tenancy and `APP_PUBLIC`: a vision brief, a roadmap and a compliance\n * programme are facts about what the application's own source SAYS about itself. There is no tenant\n * dimension and no subject whose data could leak, and the companion's loopback bind is what keeps\n * the whole workbench local.\n \n READ and LIST only, and structurally so — `PersistenceAdapter.INTROSPECTION` refuses every write\n * verb, rows are derived per read and nothing is stored. Acceptance of a specification is a human\n * git commit (`.claude/rules/one-source-of-truth.md` rule 2), so there is deliberately no place here\n * for an acceptance state to accumulate, not even by accident.\n /\nconst WorkbenchSpecificationArtifact_Operations = undefined;\n\ntype WorkbenchSpecificationArtifact_CoreOperations =\n \| CoreResourceOperation.READ\n \| CoreResourceOperation.LIST;\n\nexport const workbenchSpecificationArtifacts_ResourceConfiguration_InitializationFactory =\n (resourcesRelationships: ResourceRelationship[]) => createResourceConfiguration_Initialization<\n typeof WorkbenchSpecificationArtifact_Operations,\n WorkbenchSpecificationArtifact_CoreOperations,\n typeof Workbench_SpecificationArtifact_Schema\n >({\n mainSchema: Workbench_SpecificationArtifact_Schema,\n resourceIdentifier: WorkbenchShared_ResourceType.SPECIFICATION_ARTIFACTS,\n resourceFieldIdentifier:\n WorkbenchShared_ResourceFieldIdentifier[WorkbenchShared_ResourceType.SPECIFICATION_ARTIFACTS],\n resourceRelationships: resourcesRelationships,\n isSystemResource: false,\n persistenceAdapter: PersistenceAdapter.INTROSPECTION,\n introspectionBinding: {\n behavior: 'specification-artifacts',\n rowsPath: 'artifacts',\n tenancy: IntrospectionTenancyStance.APPLICATION_STRUCTURE,\n /\n * NO `identityFields`, and the omission is the point.\n \n Every row already carries `family`, and `family` IS this resource's\n * `resourceFieldIdentifier` — so there is nothing to compose. This is the `moduleId` case, not\n * the relationships one: declaring an identity here would stamp a composed key over a real\n * field, replacing the source's own id with a copy of itself.\n /\n },\n coreOperations: [CoreResourceOperation.READ, CoreResourceOperation.LIST],\n customOperation: WorkbenchSpecificationArtifact_Operations,\n operationsConfiguration: {\n [CoreResourceOperation.READ]: { variants: [createReadOnlyApiVariant()] },\n [CoreResourceOperation.LIST]: {\n variants: [{\n ...createReadOnlyListApiVariant(),\n /\n * The two review axes a reader slices fifteen rows by. Declaring them is an OBLIGATION,\n * not a hint: the introspection source honors exactly the scalar-equality/IN filters that\n * reach it and REFUSES shapes it cannot apply, because a declared filter that is silently\n * dropped returns the unfiltered set wearing a filtered label — the `--state ready` defect\n * class. The frontend's concern quick-filter tabs require `concern` to be here, or the\n * tab strip silently never renders.\n */\n filterFields: {\n concern: z.enum(WorkbenchSpecificationArtifactConcern).systemEnum('WorkbenchSpecificationArtifactConcern'),\n state: z.enum(WorkbenchSpecificationArtifactState).systemEnum('WorkbenchSpecificationArtifactState'),\n },\n }],\n },\n },\n });\n\nexport const workbenchShared_ResourcesConfigurationsFactoryMap = {\n [WorkbenchShared_ResourceType.DOMAIN_RESOURCES]:\n workbenchDomainResources_ResourceConfiguration_InitializationFactory,\n [WorkbenchShared_ResourceType.SPECIFICATION_ARTIFACTS]:\n workbenchSpecificationArtifacts_ResourceConfiguration_InitializationFactory,\n // The 40 family-aspect resources — generated from the descriptor table, one mold for all.\n ...workbenchAspectResources_ConfigurationsFactoryMap,\n // The creation plane — companion-RUNTIME projections (authenticated, APPLICATION_RUNTIME tenancy).\n ...workbenchCreationPlane_ResourcesConfigurationsFactoryMap,\n};\n"]}

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

@@ -57,20 +57,20 @@ export type Workbench_DomainResourceRelationship = z.infer<typeof Workbench_Doma
  * 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<{
+    workbenchDomainResourceId: z.ZodString;
+    resourceType: z.ZodString;
+    moduleId: z.ZodNullable<z.ZodString>;
+    moduleKind: z.ZodNullable<z.ZodString>;
+    subDomain: z.ZodNullable<z.ZodString>;
+    fields: 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<{
+    }, z.core.$strip>>;
+    operations: z.ZodArray<z.ZodObject<{
         operationIdentifier: z.ZodString;
         variantType: z.ZodNullable<z.ZodString>;
         variantKey: z.ZodNullable<z.ZodString>;
@@ -90,16 +90,16 @@ export declare const Workbench_DomainResource_Schema: z.ZodObject<{
         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<{
+    }, z.core.$strip>>;
+    viewRefs: z.ZodArray<z.ZodString>;
+    advanced: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    specification: z.ZodNullable<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<{
+    }, z.core.$strip>>;
+    relationships: z.ZodArray<z.ZodObject<{
         relationshipId: z.ZodString;
         resourceType1: z.ZodString;
         resourceType2: z.ZodString;
@@ -115,7 +115,7 @@ export declare const Workbench_DomainResource_Schema: z.ZodObject<{
         parentResourceRequirement: z.ZodNullable<z.ZodString>;
         primaryScope: z.ZodNullable<z.ZodString>;
         allowCycle: z.ZodBoolean;
-    }, z.core.$strip>>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type Workbench_DomainResource = z.infer<typeof Workbench_DomainResource_Schema>;
 /**
@@ -176,9 +176,9 @@ export declare enum WorkbenchSpecificationArtifactConcern {
 /**
  * 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`.
+ * Not two states, 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. */
@@ -193,7 +193,12 @@ export declare enum WorkbenchSpecificationArtifactState {
      * 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"
+    NOT_LANDED = "not_landed",
+    /**
+     * A specifications module this family depends on could not be evaluated (#3258), so nothing is known of it: it may
+     * well have landed. Its own state, because reading it as NOT_LANDED is what would offer to regenerate it.
+     */
+    UNAVAILABLE = "unavailable"
 }
 /**
  * One WARNING the family's validator reports on the landed content: where it sits in the artifact
@@ -233,17 +238,17 @@ export declare const Workbench_SpecificationArtifactWarning_Schema: z.ZodObject<
  * 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<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof WorkbenchSpecificationArtifactConcern>>>;
-    state: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof WorkbenchSpecificationArtifactState>>>;
+    family: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    contentSummary: z.ZodNullable<z.ZodString>;
+    concern: z.ZodEnum<typeof WorkbenchSpecificationArtifactConcern>;
+    state: 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>>;
+    sourcePath: z.ZodNullable<z.ZodString>;
+    errorCount: z.ZodNumber;
+    warnCount: z.ZodNumber;
+    producedByPlaybookRefs: z.ZodArray<z.ZodString>;
     content: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     document: z.ZodNullable<z.ZodString>;
     issues: z.ZodNullable<z.ZodString>;

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

	@@ -1 +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;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0L1C,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;;;;GAIG;AACH,eAAO,MAAM,6CAA6C;;;iBAGxD,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;~~iBA6HjD~~,CAAC;AAEH,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sCAAsC,CAAC,CAAC"}
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;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0L1C,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;IACzB;;;OAGG;IACH,WAAW,gBAAgB;CAC5B;AAED;;;;GAIG;AACH,eAAO,MAAM,6CAA6C;;;iBAGxD,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;iBA4HjD,CAAC;AAEH,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sCAAsC,CAAC,CAAC"}

package/dist/esm/workbench/workbench-resources.custom.shared.schemas.js CHANGED Viewed

@@ -341,9 +341,9 @@ export var WorkbenchSpecificationArtifactConcern;
 /**
  * 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`.
+ * Not two states, 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 var WorkbenchSpecificationArtifactState;
 (function (WorkbenchSpecificationArtifactState) {
@@ -360,6 +360,11 @@ export var WorkbenchSpecificationArtifactState;
      * say what the journey has left to produce.
      */
     WorkbenchSpecificationArtifactState["NOT_LANDED"] = "not_landed";
+    /**
+     * A specifications module this family depends on could not be evaluated (#3258), so nothing is known of it: it may
+     * well have landed. Its own state, because reading it as NOT_LANDED is what would offer to regenerate it.
+     */
+    WorkbenchSpecificationArtifactState["UNAVAILABLE"] = "unavailable";
 })(WorkbenchSpecificationArtifactState || (WorkbenchSpecificationArtifactState = {}));
 /**
  * One WARNING the family's validator reports on the landed content: where it sits in the artifact
@@ -473,8 +478,7 @@ export const Workbench_SpecificationArtifact_Schema = z.object({
      * whole engine into every consumer of this package for a shape only two consumers read. The two
      * readers type it themselves: the companion behavior validates through the semantic authority
      * before emitting, and the workbench templates narrow via TYPE-ONLY imports (erased at compile,
-     * zero runtime dependency). Recorded with alternatives in
-     * `.claude/plans/workbench-product-artifacts-ux-analysis.md` (D1).
+     * zero runtime dependency).
      *
      * Deliberately NOT a summary field: the LIST carries the index, and this is the heaviest thing a
      * row owns. Emitted from the RAW landed value — never from a validator's parsed output, whose

package/dist/esm/workbench/workbench-resources.custom.shared.schemas.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"workbench-resources.custom.shared.schemas.js","sourceRoot":"","sources":["../../../../src/workbench/workbench-resources.custom.shared.schemas.ts"],"names":[],"mappings":"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","sourcesContent":["import { z } from 'zod';\nimport { initZodDecorators } from '@wildo-ai/zod-decorators';\n\ninitZodDecorators(z);\n\n\n/*\n One relationship, as it rides on BOTH resources it joins.\n \n ## Why an edge appears on two rows rather than on one\n \n A relationship genuinely IS a property of both resources — \"what is `deals` related to?\" is a\n * question about `deals` and about everything `deals` touches — so carrying it on both is a\n * statement of what it means, not an encoding chosen to fit a row shape. Hanging every edge off one\n * arbitrarily-chosen endpoint would be the encoding, and the choice would have to be re-derived by\n * every reader.\n \n The consumer draws each edge once, keyed by {@link relationshipId}. The duplication costs one extra\n * copy of a small object per edge and buys a row that is complete on its own.\n \n ## Why the vocabularies are plain strings\n \n These values cross a subprocess boundary from the OBSERVED application's registry, which may be\n * built against a different engine revision than the workbench. Binding `nature` or the cardinalities to the engine enums would make a\n * row the observed application can legitimately produce unparseable here — the workbench refusing to\n * show exactly the drift it exists to reveal.\n /\nexport const Workbench_DomainResourceRelationship_Schema = z.object({\n /\n Stable identity for ONE edge within this projection, composed from every field carried about it.\n \n NOT the `resourceType1__resourceType2__foreignKeyField` triple the retired\n * `workbenchResourceRelationships` resource addressed a row by: that triple is not total here,\n * because a MANY-to-MANY edge carries\n * `jointResourceType` and no `foreignKeyField`. Two edges agreeing on every field below are\n * indistinguishable to a graph, so merging them loses nothing a reader could have seen.\n /\n relationshipId: z.string().min(1),\n resourceType1: z.string().min(1),\n resourceType2: z.string().min(1),\n cardinality1: z.string().min(1),\n cardinality2: z.string().min(1),\n /\n `composition`, `reference` or `association` — every member `RelationshipNature` declares — kept as\n * a plain string for the drift-tolerance reason above, not because a fourth one exists today.\n /\n nature: z.string().min(1),\n /* The field carrying the join. Absent on a junction-backed MANY-to-MANY, which has no FK column. /\n foreignKeyField: z.string().min(1).nullable(),\n /\n Which side's rows CARRY the foreign key — the direction an arrow must point.\n \n Resolved by the framework's own `resolveForeignKeyHolderResourceType`, from CARDINALITY, never\n * from declaration order: `(TODOS, USERS, MANY, ONE, { foreignKeyField })` is a valid child-first\n * declaration that puts the referenced resource in `resourceType2`, so a consumer reading position\n * draws half its arrows backwards.\n /\n foreignKeyHolderResourceType: z.string().min(1),\n /* The junction resource of a MANY-to-MANY, which the framework requires such an edge to name. /\n jointResourceType: z.string().min(1).nullable(),\n /* Whether this edge is the structural ownership anchor giving `resourceType2` its scope. /\n isPrimaryScope: z.boolean(),\n /\n Whether the edge is DECLARED BUT INACTIVE.\n \n The one field here whose absence made the graph WRONG rather than thinner: a disabled edge\n * constrains nothing at runtime, so drawing it like a live one tells a reader the application has\n * a relationship it does not have. Carried even though the dogfood application disables none\n * (measured 2026-08-31: 0 of 16) — a field that is uniformly `false` today is exactly the one that\n * silently misleads the first time it is not.\n /\n isDisabled: z.boolean(),\n /\n How a caller reaches rows on the far side — `requires_context`, `standalone`, and whatever else\n * the observed application's engine revision declares.\n \n A plain string for the same drift-tolerance reason `nature` is one.\n /\n accessScopeStrategy: z.string().min(1).nullable(),\n /* Whether the parent endpoint is `mandatory` or `optional` for the child's addressing. /\n parentResourceRequirement: z.string().min(1).nullable(),\n /\n WHICH resource this edge anchors scope to, when it anchors one.\n \n Not derivable from {@link isPrimaryScope}, which says only THAT it anchors. On an edge whose\n * endpoints are both scoped, the two answer different questions.\n /\n primaryScope: z.string().min(1).nullable(),\n /* Whether a cycle through this edge is permitted — a graph-shape fact a graph should be able to show. /\n allowCycle: z.boolean(),\n});\n\nexport type Workbench_DomainResourceRelationship = z.infer<typeof Workbench_DomainResourceRelationship_Schema>;\n\n/\n ONE resource of the observed application's domain model — node, module membership, specification\n * and edges in a single row.\n \n ## Why every field is a summary field\n \n A LIST renders the SUMMARY projection, and this resource's list IS its whole purpose: the graph\n * consumes the collection. A field left out of the summary is a field the graph cannot draw, and the\n * omission is silent — the row arrives, the field is simply absent. So the summary here is the full\n * row by design rather than by neglect.\n \n ## Why this is one row per RESOURCE rather than one row per module or one row for the graph\n \n Edges are resource-to-resource. A module-per-node projection would have to AGGREGATE them, which\n * destroys precisely the meanings the framework refuses to merge — nature, cardinality, foreign-key\n * direction — and a graph that draws every edge as one grey line has lost information the flat table\n * at least preserved.\n /\nexport const Workbench_DomainResource_Schema = z.object({\n /\n Composed by the introspection source from the binding's `identityFields` (`['resourceType']`).\n \n `.isSummaryField()` on the IDENTITY field is load-bearing rather than cosmetic: the projection a\n * list renders is the summary, and a row with no id is a row nothing can address — the failure that\n * made every relationship row unclickable before its id was marked.\n /\n workbenchDomainResourceId: z.string().min(1).isPrimaryKey().isSummaryField(),\n resourceType: z.string().min(1).isSummaryField(),\n /\n The module that registers this resource, or `null`.\n \n `null` is a FACT, not a gap: no module of the observed application owns this resource, which is\n * true of every ENGINE resource — and an application merges all of them, since `initializeResources`\n * applies the engine's core factory map unconditionally and both registries merge it. They are\n * carried rather than dropped because they are part of the running application, and because an edge\n * to the resource that gives a row its tenant scope is the most load-bearing edge in the graph.\n \n No `origin` field restates this. The absence of a module IS the distinction, and a second field\n * saying the same thing is a second thing that can disagree with the first.\n /\n moduleId: z.string().min(1).isSummaryField().nullable(),\n /* `domain` or `engine` — the kind the owning module declares, when there is one. /\n moduleKind: z.string().min(1).isSummaryField().nullable(),\n /\n Which part of its owner this resource belongs to — a SECOND grouping axis, under the module.\n \n Sourced from `ResourceSpecificationConfig.subDomain`. For engine resources that is the closed\n * `EngineResourceSubDomain` vocabulary (`auth`, `billing`, `users`, …), which exists because the\n * engine's 85 resources otherwise arrive as one flat set and every surface that has to present them\n * invents a grouping of its own.\n \n A plain `string` here rather than that enum, and deliberately: this schema is shared by a\n * workbench that observes an application whose own sub-domains it cannot enumerate. Pinning the\n * engine's vocabulary here would make an application's value invalid at the wire.\n \n `null` means the resource specification declares none — an application resource today, or an engine\n * resource with no spec at all. A consumer grouping by this must carry an \"unclassified\" bucket and\n * say so, rather than folding those rows into a real group.\n /\n subDomain: z.string().min(1).isSummaryField().nullable(),\n /\n Every field of the materialized `mainSchema`, with everything the framework knows about it.\n \n This replaced a bare `fieldNames: string[]`, whose JSDoc argued that \"a domain-model panel\n * answers what a resource HOLDS\" and that per-field extraction \"belongs to `resource-specifications`\".\n * The premise was right and the conclusion aged badly: a NAME answers \"does this field exist\",\n * which the node already implies by counting them, and a reader who opens a resource wants what\n * the field IS. The cost was then MEASURED rather than assumed — 715 fields across the 82 engine\n * resources extract to 264 KB, a fraction of what the relationship edges already cost — so the\n * reason to withhold it was gone.\n \n `params`, `derived` and `origin` are OPAQUE records on purpose. They are the extractor's own\n * output — authored spec prose, framework-derived structure, base-vs-variant provenance — and each\n * is an open shape that grows with the decorators. Restating them field by field here would make\n * this schema a second, always-lagging copy of a contract `@wildo-ai/saas-specifications` owns;\n * a consumer that needs one reads it through that package's type.\n /\n fields: z.array(z.object({\n fieldName: z.string().min(1),\n /* Which `{primitive}Spec()` decorator carried the authored prose, when one did. /\n specDecorator: z.string().min(1).nullable(),\n params: z.record(z.string(), z.unknown()).nullable(),\n derived: z.record(z.string(), z.unknown()).nullable(),\n origin: z.record(z.string(), z.unknown()).nullable(),\n /\n The field's DECORATOR record, as the schema declares it — beside `derived`, which is the\n * extractor's interpretation of it.\n \n It carries what the interpretation drops: `isSummaryField`, `isHidden`, `excludeFromCreate` /\n * `excludeFromUpdate`, `dataCategories`, and the index / unique / primary-key trio.\n \n It does NOT carry `.ui-behavior.tsx` configuration, and that is a reachability limit rather\n than an omission: those decorators are applied by a FRONTEND module the companion never loads,\n * because the subprocess resolves `library`, `specifications` and `service` targets and there is\n * no frontend one. Measured on the engine's resources — zero UI keys present.\n /\n metadata: z.record(z.string(), z.unknown()).nullable(),\n })).isSummaryField(),\n /\n Every operation the resource declares, projected to what a READER needs.\n \n Never the DTOs. A materialized operation carries six Zod schemas — request, response, summary,\n * context, internal, repository — each serializing to tens of kilobytes, so carrying the operation\n * objects would put megabytes on the wire to say which verbs exist. What is here is the identity,\n * the variant, the authorization and the flags that change what the operation DOES.\n \n An EMPTY `roles` array is a real answer — no role gate on that variant — and not a gap.\n /\n operations: z.array(z.object({\n operationIdentifier: z.string().min(1),\n /* The TRANSPORT kind: `api_call`, `internal_call`, `repository_only`, … /\n variantType: z.string().min(1).nullable(),\n /\n WHICH variant of that transport — `admin`, `summary`, `context` — or `null` for the default.\n \n The missing half of an operation's IDENTITY, and its absence was a defect rather than missing\n * detail: `organizations` declares four operations that are all `read` × `api_call`, separated\n * only by this key, and across the engine's core map 133 of 794 operations collided on the pair\n * without it.\n /\n variantKey: z.string().min(1).nullable(),\n /* For a CUSTOM operation, the core verb it behaves like. `null` for a core operation. /\n resourceOperationLike: z.string().min(1).nullable(),\n isDefault: z.boolean(),\n roles: z.array(z.string()),\n riskLevel: z.string().min(1).nullable(),\n isUnimplemented: z.boolean(),\n isDisabled: z.boolean(),\n requiresStepUpAuthentication: z.boolean(),\n /\n The variant's `idempotencyKey` declaration (#535) — `accepted` or `required` — or null when it takes no key. A plain\n * string for the same reason as the other vocabularies here: the observed application may run another engine revision.\n /\n idempotencyKey: z.string().min(1).nullable(),\n /\n The action the variant's `submissionChallenge` declaration binds a caller's captcha token to (#1985), or null when a\n * caller who is not signed in answers no challenge. A plain string: an application names its own actions.\n /\n submissionChallengeAction: z.string().min(1).nullable(),\n admitsCrossTenantPlatformAdministration: z.boolean(),\n auditableEventType: z.string().min(1).nullable(),\n isMcpExposed: z.boolean(),\n requiredFeatures: z.array(z.string()),\n /\n Everything else the operation declares — HTTP verb, runtime mode, bulk and API-key posture,\n * notification fan-out, custom-implementation modes, authoritative fields.\n \n A DENY LIST over the operation's own keys on the producing side, for the same reason `advanced`\n * is, and this is the one that proved the argument: a hand-picked set of twelve fields shipped\n * without `variantKey`, `httpVerb`, `isBulkOperation` or `serviceRuntimeMode`. The six DTO\n * schemas are excluded by name — each serializes to tens of kilobytes.\n /\n attributes: z.record(z.string(), z.unknown()),\n /\n The authored specification for this operation, keyed by `operationIdentifier` — so every\n * VARIANT of one verb carries the same entry, which is what the specification describes.\n \n `null` means the specification does not mention the operation: a gap a reader can act on.\n /\n specification: z.record(z.string(), z.unknown()).nullable(),\n /* The authored `frontend.views` overlay for this operation, when there is one. /\n view: z.record(z.string(), z.unknown()).nullable(),\n })).isSummaryField(),\n /\n The operations for which the resource specification declares a FRONTEND view overlay (`frontend.views`).\n \n Refs only. The entries are authoring prose about how an operation surfaces, which belongs to a\n * specification reader; what a domain-model panel can act on is which operations have an authored\n * view and — by difference with `operations` — which do not.\n /\n viewRefs: z.array(z.string()).isSummaryField(),\n /\n The configuration facts that are neither prose nor structure — persistence, policy, bindings.\n \n Everything on the resource's `ResourceConfiguration` that decides how it BEHAVES rather than what\n * it holds: which database it lives in, whether it is a system resource, its retention,\n * transposition, portability and data-subject policies, its HTTP and introspection bindings.\n \n An OPAQUE record, and deliberately so. The producer builds it by DENY list over the\n * configuration's own keys rather than by enumerating the ones that exist today, because\n * `ResourceConfiguration` has grown several of these fields in as many months and an enumeration\n * reports the subset its author knew about. Typing it here would put that enumeration back.\n /\n advanced: z.record(z.string(), z.unknown()).isSummaryField(),\n /\n The authored specification's PROSE, or `null` when this resource has none.\n \n It rides in the row rather than being fetched on selection because a per-selection fetch is not\n * cheaper: `deriveRows` has no per-row path, so an addressed READ derives the WHOLE set and filters\n * it afterwards. \"Fetch the specification when a node is clicked\" would therefore be a second full\n * derivation of the entire application.\n /\n specification: z.object({\n /* Why this resource exists in the domain. /\n purpose: z.string(),\n /* The functional role it plays inside the business architecture. /\n businessRole: z.string(),\n /* How it evolves over time. Optional in the specification contract, so nullable here. /\n lifecycleRole: z.string().nullable(),\n /* Domain caveats not encoded structurally elsewhere. /\n businessConstraints: z.array(z.string()),\n }).isSummaryField().nullable(),\n /* Every relationship this resource participates in, on either side. /\n relationships: z.array(Workbench_DomainResourceRelationship_Schema).isSummaryField(),\n});\n\nexport type Workbench_DomainResource = z.infer<typeof Workbench_DomainResource_Schema>;\n\n/\n ONE FIELD of a domain resource — named so a consumer can hold one without re-deriving its type.\n \n Indexed off the row rather than declared separately, because the schema is the one authority for\n * the shape and a second declaration is a second thing that can drift from it.\n /\nexport type Workbench_DomainResourceField = Workbench_DomainResource['fields'][number];\n\n/* ONE OPERATION of a domain resource — indexed off the row, for the same reason. /\nexport type Workbench_DomainResourceOperation = Workbench_DomainResource['operations'][number];\n\n/\n The QUESTION a specification family answers — the axis the workbench groups them by.\n \n ## Why the families are grouped at all\n \n Fifteen rows in one undifferentiated list is a directory, not a review surface. A creator opening\n * the workbench is not looking for \"the `document-release-policy` family\"; they are looking for what\n * was decided about who this product is for, or about what it must promise. Grouping by the question\n * answered is what makes the list navigable without inventing twelve destinations.\n \n ## Why this is a display vocabulary and not a property of the family\n \n `ApplicationSpecificationFamilySemanticSchemaRef` names what a family MEANS and what validates it.\n * Nothing in the runtime branches on the concern below — it exists so a reader can find a row. Adding\n * it to the semantic authority would put a workbench presentation choice inside the contract the\n * journey lands artifacts against.\n \n The family → concern mapping deliberately lives with the projection that derives it (the\n * companion's `specification-artifacts` behavior), beside the semantic authority it must stay\n * exhaustive over, rather than here where the authority is not reachable.\n /\nexport enum WorkbenchSpecificationArtifactConcern {\n /* Why the product exists and who it is for — `vision-brief`, `market-snapshot`. /\n INTENT = 'intent',\n /* What it must do and what it costs — `requirements`, `feature-drafts`, `business-model`. /\n SCOPE = 'scope',\n /* How and when it gets built — `domain-plan`, `build-plan`, `roadmap`, `placement-plan`. /\n DELIVERY = 'delivery',\n /* How it presents itself — `brand-brief`. /\n IDENTITY = 'identity',\n /* What it must promise and publish — the assurance and governed-document families. /\n OBLIGATIONS = 'obligations',\n /\n A family the workbench has not been taught to group.\n \n A named member rather than a throw, and rather than silence. The population is derived from the\n * semantic authority, so a family added there arrives here with no classification — and the two\n * alternatives are both worse than a visible bucket: refusing the derivation would blank the whole\n * page over one unmapped row, and defaulting into a real concern would file the new family\n * somewhere plausible and wrong, which nobody would notice.\n \n A companion test asserts this member is currently UNUSED, so it stays a signal rather than\n * becoming a habit.\n /\n UNCLASSIFIED = 'unclassified',\n}\n\n/\n Whether a family has landed, and whether what landed still validates.\n \n THREE states, not two, because \"not landed\" and \"landed but invalid\" are the opposite instructions\n * to a reviewer: the first is work the journey has not done, the second is work it did that no longer\n * holds. A boolean `isValid` would report both as `false`.\n /\nexport enum WorkbenchSpecificationArtifactState {\n /* The family is exported by the application and its `_core` validator reports no error. /\n LANDED_VALID = 'landed_valid',\n /* The family is exported and its `_core` validator reports at least one ERROR-severity issue. /\n LANDED_INVALID = 'landed_invalid',\n /\n The application exports nothing for this family.\n \n Reported as a ROW rather than omitted — the same call `definition-specifications.behavior.ts`\n * makes for the same reason: \"an omitted row and a family that does not exist would look the same\n to the reader.\"* On a fresh application an empty list would say nothing; fifteen NOT_LANDED rows\n * say what the journey has left to produce.\n /\n NOT_LANDED = 'not_landed',\n}\n\n/\n One WARNING the family's validator reports on the landed content: where it sits in the artifact\n * (`path`, the validator's own dotted locator) and what it says (`message`, the validator's words).\n * A warning is authoring drift that does not invalidate the artifact — see `warnCount`.\n /\nexport const Workbench_SpecificationArtifactWarning_Schema = z.object({\n path: z.string(),\n message: z.string(),\n});\n\n/\n ONE application-specification family, projected for a human reviewer.\n \n ## Why the prose fields are markdown strings\n \n `StringDisplayMode.MARKDOWN` renders GFM through the framework's own display chrome, which is what\n * lets headings, lists and paragraphs survive into the page. The alternative — modelling each\n * family's shape as nested schema fields — would have to be done fifteen times, would freeze twelve\n * `_core` contracts into this projection, and would still render as a form rather than as a document.\n \n The rendering is an OUTLINE, never a table. That is the acceptance criterion this resource exists\n * to satisfy: these artifacts are prose-heavy and their value is in the rationale, so a projection\n * that put them in columns would destroy exactly what makes them worth reviewing.\n \n ## Why the heavy fields are NOT summary fields\n \n `document`, `issues`, `warnings`, `decisionRecord` and `diagram` are excluded from the summary by omission, so\n * a list carries the INDEX while a detail page carries the documents. One derivation still computes\n * all of them either way — this bounds the RESPONSE, not the work.\n \n Which variant a caller gets matters, and is easy to state wrongly: the LIST operation's DEFAULT\n * variant answers the full row, and it is the operation's `summary` variant that applies this\n * projection. Measured against the live wonder-crm companion, 2026-08-31:\n * `GET /api/v1/workbench-specification-artifacts` → 149,089 B, and\n * `…/workbench-specification-artifacts/summary` → 3,654 B carrying the eight fields marked\n * below. A list layout renders the summary variant — which is also why the addressing field must be\n * marked, or every row in that list is unclickable.\n /\nexport const Workbench_SpecificationArtifact_Schema = z.object({\n /\n The family id — `vision-brief`, `market-snapshot`, `compliance-program`.\n \n The source's own key, marked `.isSummaryField()` because a list row with no id is a row nothing\n * can address: the summary projection is what a click reads the target from.\n /\n family: z.string().min(1).isPrimaryKey().isSummaryField(),\n /* The family's name in a creator's words — `Vision`, `Market`, `Assurance programme`. /\n title: z.string().min(1).isSummaryField(),\n /\n What this family IS, in one sentence a creator recognizes — static per family, present whether\n * or not anything landed. This is the summary card's subtitle: a card reading only\n * \"Governed-document drafts · Not landed\" tells a reader nothing they can act on; \"The drafts of\n * the public documents this product must publish\" does.\n /\n description: z.string().min(1).isSummaryField(),\n /\n A one-line PULSE of the landed content — `\"3 ICPs · 5 personas · 2 positionings\"`, the vision's\n * own one-liner — or `null` when the family has not landed.\n \n Derived server-side from the RAW value so the list answers \"how much is in there\" without any\n * client downloading fifteen full documents. It is a COUNT-and-headline summary, never a\n * truncation of prose: a clipped sentence reads as an accident, a count reads as an answer.\n /\n contentSummary: z.string().nullable().isSummaryField(),\n /* The question this family answers, which is the axis the list groups by. /\n concern: z.enum(WorkbenchSpecificationArtifactConcern).systemEnum('WorkbenchSpecificationArtifactConcern').isSummaryField(),\n /* Landed and valid, landed and invalid, or not landed at all. /\n state: z.enum(WorkbenchSpecificationArtifactState).systemEnum('WorkbenchSpecificationArtifactState').isSummaryField(),\n /* The `_core` contract the family's content must satisfy, verbatim from the semantic authority. /\n schemaRef: z.string().min(1),\n /\n Where the family's file lives, relative to the application root — the file a reader opens when\n * the rendering is not enough.\n \n `null` when this runtime places no file for the family. A placement and a RENDER PROFILE are\n * different things (`playbook-output-landing-target`), and only the placement is asked for here.\n /\n sourcePath: z.string().min(1).nullable().isSummaryField(),\n /* ERROR-severity issues the family's own validator reports on the landed content, right now. /\n errorCount: z.number().int().nonnegative().isSummaryField(),\n /* WARN-severity issues — authoring drift that does not invalidate the artifact. /\n warnCount: z.number().int().nonnegative().isSummaryField(),\n /\n Every playbook whose declared `outputs[].family` is this family.\n \n This is the durable half of \"what produced it\": a fact about the compiled catalog, in git, true\n * whether or not any run's state survives. A link to the RUN that produced this particular value\n * was deliberately rejected — runs, traces and the write register are a per-run cache under\n * `one-source-of-truth.md` Rule 5, so a durable artifact pointing into deletable state is dangling\n * by design. The link runs the other way: a run may name what it wrote.\n \n Empty for a family no playbook produces — which is a finding, not a gap.\n /\n producedByPlaybookRefs: z.array(z.string()).isSummaryField(),\n /\n The landed family value, RAW — exactly the object the specifications package exports.\n \n ## Why the raw value rides beside its rendering\n \n The per-family presentations (workbench `artifact-presentation/`) render EDITORIALLY — an ICP\n * card, a requirement with its acceptance criteria, a placement decision with its rationale — and\n * an editorial arrangement needs the VALUE, not a markdown projection of it. The markdown\n * `document` below stays: it is the structural fallback every family keeps behind the content\n * error boundary, and the whole rendering for a family this build's vocabulary does not know.\n \n ## Untyped HERE, typed at the EDGE — a measured decision, not an omission\n \n The typed `_core` snapshot schemas live in `@wildo-ai/saas-specifications`, which depends on\n * `saas-frontend-lib` AND `saas-backend-lib` (its package.json) — while this package is the\n * platform's light contracts-only spine (`platform/CLAUDE.md`). Typing this field would drag the\n * whole engine into every consumer of this package for a shape only two consumers read. The two\n * readers type it themselves: the companion behavior validates through the semantic authority\n * before emitting, and the workbench templates narrow via TYPE-ONLY imports (erased at compile,\n * zero runtime dependency). Recorded with alternatives in\n * `.claude/plans/workbench-product-artifacts-ux-analysis.md` (D1).\n \n Deliberately NOT a summary field: the LIST carries the index, and this is the heaviest thing a\n * row owns. Emitted from the RAW landed value — never from a validator's parsed output, whose\n * schema `.default()`s would inject content the author never wrote.\n /\n content: z.record(z.string(), z.unknown()).nullable(),\n /\n The artifact rendered as a document, or `null` when the family has not landed.\n \n Produced by `renderSpecificationFamilyReviewDocument` — an outline over the landed value, not a\n * prompt block. The prompt renderers (`market-render-prompt`, `brand-render-prompt`) read the same\n * content for a language model and must never be reused here.\n /\n document: z.string().nullable(),\n /\n The validator's own findings, rendered for a reader, or `null` when there are none.\n \n Carried as content rather than as counts alone because a reviewer deciding whether to accept an\n * artifact needs to see WHICH rule failed and where, and the counts beside them in the list are\n * only the signal to come and look.\n /\n issues: z.string().nullable(),\n /\n Every WARNING the validator reports, structured, one entry per finding — `[]` when there are\n * none or the family has not landed. `warnCount` is its length.\n \n Structured rather than folded into `issues` (which carries the ERRORS) so the page names them in\n * its own authored words: until 2026-09-25 only the count left the companion, and the page could say\n * \"25 warnings\" and then had to send the reader to the file to learn what they were.\n /\n warnings: z.array(Workbench_SpecificationArtifactWarning_Schema),\n /\n `DECISIONS.md` committed beside the family, verbatim, or `null` when there is none.\n \n The strongest provenance this surface has: it names the playbook that produced the artifact and,\n * more importantly, records every question the creator was asked — including the ones they did NOT\n * answer, where \"the derivation chose for itself\". A run that asked nothing writes no such file, so\n * `null` here means \"no clarification was recorded\", never \"no clarification happened\".\n /\n decisionRecord: z.string().nullable(),\n /\n `DIAGRAM.md` committed beside the family, verbatim, or `null`.\n \n Three families have one today (`domain-plan`, `build-plan`, `roadmap`). It is surfaced rather\n * than re-derived: the diagram is already a committed output of the family, regenerated on every\n * landing, and rendering a second picture here would be a second thing that can disagree with it.\n */\n diagram: z.string().nullable(),\n});\n\nexport type Workbench_SpecificationArtifact = z.infer<typeof Workbench_SpecificationArtifact_Schema>;\n"]}
1	+ {"version":3,"file":"workbench-resources.custom.shared.schemas.js","sourceRoot":"","sources":["../../../src/workbench/workbench-resources.custom.shared.schemas.ts"],"names":[],"mappings":"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","sourcesContent":["import { z } from 'zod';\nimport { initZodDecorators } from '@wildo-ai/zod-decorators';\n\ninitZodDecorators(z);\n\n\n/*\n One relationship, as it rides on BOTH resources it joins.\n \n ## Why an edge appears on two rows rather than on one\n \n A relationship genuinely IS a property of both resources — \"what is `deals` related to?\" is a\n * question about `deals` and about everything `deals` touches — so carrying it on both is a\n * statement of what it means, not an encoding chosen to fit a row shape. Hanging every edge off one\n * arbitrarily-chosen endpoint would be the encoding, and the choice would have to be re-derived by\n * every reader.\n \n The consumer draws each edge once, keyed by {@link relationshipId}. The duplication costs one extra\n * copy of a small object per edge and buys a row that is complete on its own.\n \n ## Why the vocabularies are plain strings\n \n These values cross a subprocess boundary from the OBSERVED application's registry, which may be\n * built against a different engine revision than the workbench. Binding `nature` or the cardinalities to the engine enums would make a\n * row the observed application can legitimately produce unparseable here — the workbench refusing to\n * show exactly the drift it exists to reveal.\n /\nexport const Workbench_DomainResourceRelationship_Schema = z.object({\n /\n Stable identity for ONE edge within this projection, composed from every field carried about it.\n \n NOT the `resourceType1__resourceType2__foreignKeyField` triple the retired\n * `workbenchResourceRelationships` resource addressed a row by: that triple is not total here,\n * because a MANY-to-MANY edge carries\n * `jointResourceType` and no `foreignKeyField`. Two edges agreeing on every field below are\n * indistinguishable to a graph, so merging them loses nothing a reader could have seen.\n /\n relationshipId: z.string().min(1),\n resourceType1: z.string().min(1),\n resourceType2: z.string().min(1),\n cardinality1: z.string().min(1),\n cardinality2: z.string().min(1),\n /\n `composition`, `reference` or `association` — every member `RelationshipNature` declares — kept as\n * a plain string for the drift-tolerance reason above, not because a fourth one exists today.\n /\n nature: z.string().min(1),\n /* The field carrying the join. Absent on a junction-backed MANY-to-MANY, which has no FK column. /\n foreignKeyField: z.string().min(1).nullable(),\n /\n Which side's rows CARRY the foreign key — the direction an arrow must point.\n \n Resolved by the framework's own `resolveForeignKeyHolderResourceType`, from CARDINALITY, never\n * from declaration order: `(TODOS, USERS, MANY, ONE, { foreignKeyField })` is a valid child-first\n * declaration that puts the referenced resource in `resourceType2`, so a consumer reading position\n * draws half its arrows backwards.\n /\n foreignKeyHolderResourceType: z.string().min(1),\n /* The junction resource of a MANY-to-MANY, which the framework requires such an edge to name. /\n jointResourceType: z.string().min(1).nullable(),\n /* Whether this edge is the structural ownership anchor giving `resourceType2` its scope. /\n isPrimaryScope: z.boolean(),\n /\n Whether the edge is DECLARED BUT INACTIVE.\n \n The one field here whose absence made the graph WRONG rather than thinner: a disabled edge\n * constrains nothing at runtime, so drawing it like a live one tells a reader the application has\n * a relationship it does not have. Carried even though the dogfood application disables none\n * (measured 2026-08-31: 0 of 16) — a field that is uniformly `false` today is exactly the one that\n * silently misleads the first time it is not.\n /\n isDisabled: z.boolean(),\n /\n How a caller reaches rows on the far side — `requires_context`, `standalone`, and whatever else\n * the observed application's engine revision declares.\n \n A plain string for the same drift-tolerance reason `nature` is one.\n /\n accessScopeStrategy: z.string().min(1).nullable(),\n /* Whether the parent endpoint is `mandatory` or `optional` for the child's addressing. /\n parentResourceRequirement: z.string().min(1).nullable(),\n /\n WHICH resource this edge anchors scope to, when it anchors one.\n \n Not derivable from {@link isPrimaryScope}, which says only THAT it anchors. On an edge whose\n * endpoints are both scoped, the two answer different questions.\n /\n primaryScope: z.string().min(1).nullable(),\n /* Whether a cycle through this edge is permitted — a graph-shape fact a graph should be able to show. /\n allowCycle: z.boolean(),\n});\n\nexport type Workbench_DomainResourceRelationship = z.infer<typeof Workbench_DomainResourceRelationship_Schema>;\n\n/\n ONE resource of the observed application's domain model — node, module membership, specification\n * and edges in a single row.\n \n ## Why every field is a summary field\n \n A LIST renders the SUMMARY projection, and this resource's list IS its whole purpose: the graph\n * consumes the collection. A field left out of the summary is a field the graph cannot draw, and the\n * omission is silent — the row arrives, the field is simply absent. So the summary here is the full\n * row by design rather than by neglect.\n \n ## Why this is one row per RESOURCE rather than one row per module or one row for the graph\n \n Edges are resource-to-resource. A module-per-node projection would have to AGGREGATE them, which\n * destroys precisely the meanings the framework refuses to merge — nature, cardinality, foreign-key\n * direction — and a graph that draws every edge as one grey line has lost information the flat table\n * at least preserved.\n /\nexport const Workbench_DomainResource_Schema = z.object({\n /\n Composed by the introspection source from the binding's `identityFields` (`['resourceType']`).\n \n `.isSummaryField()` on the IDENTITY field is load-bearing rather than cosmetic: the projection a\n * list renders is the summary, and a row with no id is a row nothing can address — the failure that\n * made every relationship row unclickable before its id was marked.\n /\n workbenchDomainResourceId: z.string().min(1).isPrimaryKey().isSummaryField(),\n resourceType: z.string().min(1).isSummaryField(),\n /\n The module that registers this resource, or `null`.\n \n `null` is a FACT, not a gap: no module of the observed application owns this resource, which is\n * true of every ENGINE resource — and an application merges all of them, since `initializeResources`\n * applies the engine's core factory map unconditionally and both registries merge it. They are\n * carried rather than dropped because they are part of the running application, and because an edge\n * to the resource that gives a row its tenant scope is the most load-bearing edge in the graph.\n \n No `origin` field restates this. The absence of a module IS the distinction, and a second field\n * saying the same thing is a second thing that can disagree with the first.\n /\n moduleId: z.string().min(1).isSummaryField().nullable(),\n /* `domain` or `engine` — the kind the owning module declares, when there is one. /\n moduleKind: z.string().min(1).isSummaryField().nullable(),\n /\n Which part of its owner this resource belongs to — a SECOND grouping axis, under the module.\n \n Sourced from `ResourceSpecificationConfig.subDomain`. For engine resources that is the closed\n * `EngineResourceSubDomain` vocabulary (`auth`, `billing`, `users`, …), which exists because the\n * engine's 85 resources otherwise arrive as one flat set and every surface that has to present them\n * invents a grouping of its own.\n \n A plain `string` here rather than that enum, and deliberately: this schema is shared by a\n * workbench that observes an application whose own sub-domains it cannot enumerate. Pinning the\n * engine's vocabulary here would make an application's value invalid at the wire.\n \n `null` means the resource specification declares none — an application resource today, or an engine\n * resource with no spec at all. A consumer grouping by this must carry an \"unclassified\" bucket and\n * say so, rather than folding those rows into a real group.\n /\n subDomain: z.string().min(1).isSummaryField().nullable(),\n /\n Every field of the materialized `mainSchema`, with everything the framework knows about it.\n \n This replaced a bare `fieldNames: string[]`, whose JSDoc argued that \"a domain-model panel\n * answers what a resource HOLDS\" and that per-field extraction \"belongs to `resource-specifications`\".\n * The premise was right and the conclusion aged badly: a NAME answers \"does this field exist\",\n * which the node already implies by counting them, and a reader who opens a resource wants what\n * the field IS. The cost was then MEASURED rather than assumed — 715 fields across the 82 engine\n * resources extract to 264 KB, a fraction of what the relationship edges already cost — so the\n * reason to withhold it was gone.\n \n `params`, `derived` and `origin` are OPAQUE records on purpose. They are the extractor's own\n * output — authored spec prose, framework-derived structure, base-vs-variant provenance — and each\n * is an open shape that grows with the decorators. Restating them field by field here would make\n * this schema a second, always-lagging copy of a contract `@wildo-ai/saas-specifications` owns;\n * a consumer that needs one reads it through that package's type.\n /\n fields: z.array(z.object({\n fieldName: z.string().min(1),\n /* Which `{primitive}Spec()` decorator carried the authored prose, when one did. /\n specDecorator: z.string().min(1).nullable(),\n params: z.record(z.string(), z.unknown()).nullable(),\n derived: z.record(z.string(), z.unknown()).nullable(),\n origin: z.record(z.string(), z.unknown()).nullable(),\n /\n The field's DECORATOR record, as the schema declares it — beside `derived`, which is the\n * extractor's interpretation of it.\n \n It carries what the interpretation drops: `isSummaryField`, `isHidden`, `excludeFromCreate` /\n * `excludeFromUpdate`, `dataCategories`, and the index / unique / primary-key trio.\n \n It does NOT carry `.ui-behavior.tsx` configuration, and that is a reachability limit rather\n than an omission: those decorators are applied by a FRONTEND module the companion never loads,\n * because the subprocess resolves `library`, `specifications` and `service` targets and there is\n * no frontend one. Measured on the engine's resources — zero UI keys present.\n /\n metadata: z.record(z.string(), z.unknown()).nullable(),\n })).isSummaryField(),\n /\n Every operation the resource declares, projected to what a READER needs.\n \n Never the DTOs. A materialized operation carries six Zod schemas — request, response, summary,\n * context, internal, repository — each serializing to tens of kilobytes, so carrying the operation\n * objects would put megabytes on the wire to say which verbs exist. What is here is the identity,\n * the variant, the authorization and the flags that change what the operation DOES.\n \n An EMPTY `roles` array is a real answer — no role gate on that variant — and not a gap.\n /\n operations: z.array(z.object({\n operationIdentifier: z.string().min(1),\n /* The TRANSPORT kind: `api_call`, `internal_call`, `repository_only`, … /\n variantType: z.string().min(1).nullable(),\n /\n WHICH variant of that transport — `admin`, `summary`, `context` — or `null` for the default.\n \n The missing half of an operation's IDENTITY, and its absence was a defect rather than missing\n * detail: `organizations` declares four operations that are all `read` × `api_call`, separated\n * only by this key, and across the engine's core map 133 of 794 operations collided on the pair\n * without it.\n /\n variantKey: z.string().min(1).nullable(),\n /* For a CUSTOM operation, the core verb it behaves like. `null` for a core operation. /\n resourceOperationLike: z.string().min(1).nullable(),\n isDefault: z.boolean(),\n roles: z.array(z.string()),\n riskLevel: z.string().min(1).nullable(),\n isUnimplemented: z.boolean(),\n isDisabled: z.boolean(),\n requiresStepUpAuthentication: z.boolean(),\n /\n The variant's `idempotencyKey` declaration (#535) — `accepted` or `required` — or null when it takes no key. A plain\n * string for the same reason as the other vocabularies here: the observed application may run another engine revision.\n /\n idempotencyKey: z.string().min(1).nullable(),\n /\n The action the variant's `submissionChallenge` declaration binds a caller's captcha token to (#1985), or null when a\n * caller who is not signed in answers no challenge. A plain string: an application names its own actions.\n /\n submissionChallengeAction: z.string().min(1).nullable(),\n admitsCrossTenantPlatformAdministration: z.boolean(),\n auditableEventType: z.string().min(1).nullable(),\n isMcpExposed: z.boolean(),\n requiredFeatures: z.array(z.string()),\n /\n Everything else the operation declares — HTTP verb, runtime mode, bulk and API-key posture,\n * notification fan-out, custom-implementation modes, authoritative fields.\n \n A DENY LIST over the operation's own keys on the producing side, for the same reason `advanced`\n * is, and this is the one that proved the argument: a hand-picked set of twelve fields shipped\n * without `variantKey`, `httpVerb`, `isBulkOperation` or `serviceRuntimeMode`. The six DTO\n * schemas are excluded by name — each serializes to tens of kilobytes.\n /\n attributes: z.record(z.string(), z.unknown()),\n /\n The authored specification for this operation, keyed by `operationIdentifier` — so every\n * VARIANT of one verb carries the same entry, which is what the specification describes.\n \n `null` means the specification does not mention the operation: a gap a reader can act on.\n /\n specification: z.record(z.string(), z.unknown()).nullable(),\n /* The authored `frontend.views` overlay for this operation, when there is one. /\n view: z.record(z.string(), z.unknown()).nullable(),\n })).isSummaryField(),\n /\n The operations for which the resource specification declares a FRONTEND view overlay (`frontend.views`).\n \n Refs only. The entries are authoring prose about how an operation surfaces, which belongs to a\n * specification reader; what a domain-model panel can act on is which operations have an authored\n * view and — by difference with `operations` — which do not.\n /\n viewRefs: z.array(z.string()).isSummaryField(),\n /\n The configuration facts that are neither prose nor structure — persistence, policy, bindings.\n \n Everything on the resource's `ResourceConfiguration` that decides how it BEHAVES rather than what\n * it holds: which database it lives in, whether it is a system resource, its retention,\n * transposition, portability and data-subject policies, its HTTP and introspection bindings.\n \n An OPAQUE record, and deliberately so. The producer builds it by DENY list over the\n * configuration's own keys rather than by enumerating the ones that exist today, because\n * `ResourceConfiguration` has grown several of these fields in as many months and an enumeration\n * reports the subset its author knew about. Typing it here would put that enumeration back.\n /\n advanced: z.record(z.string(), z.unknown()).isSummaryField(),\n /\n The authored specification's PROSE, or `null` when this resource has none.\n \n It rides in the row rather than being fetched on selection because a per-selection fetch is not\n * cheaper: `deriveRows` has no per-row path, so an addressed READ derives the WHOLE set and filters\n * it afterwards. \"Fetch the specification when a node is clicked\" would therefore be a second full\n * derivation of the entire application.\n /\n specification: z.object({\n /* Why this resource exists in the domain. /\n purpose: z.string(),\n /* The functional role it plays inside the business architecture. /\n businessRole: z.string(),\n /* How it evolves over time. Optional in the specification contract, so nullable here. /\n lifecycleRole: z.string().nullable(),\n /* Domain caveats not encoded structurally elsewhere. /\n businessConstraints: z.array(z.string()),\n }).isSummaryField().nullable(),\n /* Every relationship this resource participates in, on either side. /\n relationships: z.array(Workbench_DomainResourceRelationship_Schema).isSummaryField(),\n});\n\nexport type Workbench_DomainResource = z.infer<typeof Workbench_DomainResource_Schema>;\n\n/\n ONE FIELD of a domain resource — named so a consumer can hold one without re-deriving its type.\n \n Indexed off the row rather than declared separately, because the schema is the one authority for\n * the shape and a second declaration is a second thing that can drift from it.\n /\nexport type Workbench_DomainResourceField = Workbench_DomainResource['fields'][number];\n\n/* ONE OPERATION of a domain resource — indexed off the row, for the same reason. /\nexport type Workbench_DomainResourceOperation = Workbench_DomainResource['operations'][number];\n\n/\n The QUESTION a specification family answers — the axis the workbench groups them by.\n \n ## Why the families are grouped at all\n \n Fifteen rows in one undifferentiated list is a directory, not a review surface. A creator opening\n * the workbench is not looking for \"the `document-release-policy` family\"; they are looking for what\n * was decided about who this product is for, or about what it must promise. Grouping by the question\n * answered is what makes the list navigable without inventing twelve destinations.\n \n ## Why this is a display vocabulary and not a property of the family\n \n `ApplicationSpecificationFamilySemanticSchemaRef` names what a family MEANS and what validates it.\n * Nothing in the runtime branches on the concern below — it exists so a reader can find a row. Adding\n * it to the semantic authority would put a workbench presentation choice inside the contract the\n * journey lands artifacts against.\n \n The family → concern mapping deliberately lives with the projection that derives it (the\n * companion's `specification-artifacts` behavior), beside the semantic authority it must stay\n * exhaustive over, rather than here where the authority is not reachable.\n /\nexport enum WorkbenchSpecificationArtifactConcern {\n /* Why the product exists and who it is for — `vision-brief`, `market-snapshot`. /\n INTENT = 'intent',\n /* What it must do and what it costs — `requirements`, `feature-drafts`, `business-model`. /\n SCOPE = 'scope',\n /* How and when it gets built — `domain-plan`, `build-plan`, `roadmap`, `placement-plan`. /\n DELIVERY = 'delivery',\n /* How it presents itself — `brand-brief`. /\n IDENTITY = 'identity',\n /* What it must promise and publish — the assurance and governed-document families. /\n OBLIGATIONS = 'obligations',\n /\n A family the workbench has not been taught to group.\n \n A named member rather than a throw, and rather than silence. The population is derived from the\n * semantic authority, so a family added there arrives here with no classification — and the two\n * alternatives are both worse than a visible bucket: refusing the derivation would blank the whole\n * page over one unmapped row, and defaulting into a real concern would file the new family\n * somewhere plausible and wrong, which nobody would notice.\n \n A companion test asserts this member is currently UNUSED, so it stays a signal rather than\n * becoming a habit.\n /\n UNCLASSIFIED = 'unclassified',\n}\n\n/\n Whether a family has landed, and whether what landed still validates.\n \n Not two states, because \"not landed\" and \"landed but invalid\" are the opposite instructions to a\n * reviewer: the first is work the journey has not done, the second is work it did that no longer holds.\n * A boolean `isValid` would report both as `false`.\n /\nexport enum WorkbenchSpecificationArtifactState {\n /* The family is exported by the application and its `_core` validator reports no error. /\n LANDED_VALID = 'landed_valid',\n /* The family is exported and its `_core` validator reports at least one ERROR-severity issue. /\n LANDED_INVALID = 'landed_invalid',\n /\n The application exports nothing for this family.\n \n Reported as a ROW rather than omitted — the same call `definition-specifications.behavior.ts`\n * makes for the same reason: \"an omitted row and a family that does not exist would look the same\n to the reader.\"* On a fresh application an empty list would say nothing; fifteen NOT_LANDED rows\n * say what the journey has left to produce.\n /\n NOT_LANDED = 'not_landed',\n /\n A specifications module this family depends on could not be evaluated (#3258), so nothing is known of it: it may\n * well have landed. Its own state, because reading it as NOT_LANDED is what would offer to regenerate it.\n /\n UNAVAILABLE = 'unavailable',\n}\n\n/\n One WARNING the family's validator reports on the landed content: where it sits in the artifact\n * (`path`, the validator's own dotted locator) and what it says (`message`, the validator's words).\n * A warning is authoring drift that does not invalidate the artifact — see `warnCount`.\n /\nexport const Workbench_SpecificationArtifactWarning_Schema = z.object({\n path: z.string(),\n message: z.string(),\n});\n\n/\n ONE application-specification family, projected for a human reviewer.\n \n ## Why the prose fields are markdown strings\n \n `StringDisplayMode.MARKDOWN` renders GFM through the framework's own display chrome, which is what\n * lets headings, lists and paragraphs survive into the page. The alternative — modelling each\n * family's shape as nested schema fields — would have to be done fifteen times, would freeze twelve\n * `_core` contracts into this projection, and would still render as a form rather than as a document.\n \n The rendering is an OUTLINE, never a table. That is the acceptance criterion this resource exists\n * to satisfy: these artifacts are prose-heavy and their value is in the rationale, so a projection\n * that put them in columns would destroy exactly what makes them worth reviewing.\n \n ## Why the heavy fields are NOT summary fields\n \n `document`, `issues`, `warnings`, `decisionRecord` and `diagram` are excluded from the summary by omission, so\n * a list carries the INDEX while a detail page carries the documents. One derivation still computes\n * all of them either way — this bounds the RESPONSE, not the work.\n \n Which variant a caller gets matters, and is easy to state wrongly: the LIST operation's DEFAULT\n * variant answers the full row, and it is the operation's `summary` variant that applies this\n * projection. Measured against the live wonder-crm companion, 2026-08-31:\n * `GET /api/v1/workbench-specification-artifacts` → 149,089 B, and\n * `…/workbench-specification-artifacts/summary` → 3,654 B carrying the eight fields marked\n * below. A list layout renders the summary variant — which is also why the addressing field must be\n * marked, or every row in that list is unclickable.\n /\nexport const Workbench_SpecificationArtifact_Schema = z.object({\n /\n The family id — `vision-brief`, `market-snapshot`, `compliance-program`.\n \n The source's own key, marked `.isSummaryField()` because a list row with no id is a row nothing\n * can address: the summary projection is what a click reads the target from.\n /\n family: z.string().min(1).isPrimaryKey().isSummaryField(),\n /* The family's name in a creator's words — `Vision`, `Market`, `Assurance programme`. /\n title: z.string().min(1).isSummaryField(),\n /\n What this family IS, in one sentence a creator recognizes — static per family, present whether\n * or not anything landed. This is the summary card's subtitle: a card reading only\n * \"Governed-document drafts · Not landed\" tells a reader nothing they can act on; \"The drafts of\n * the public documents this product must publish\" does.\n /\n description: z.string().min(1).isSummaryField(),\n /\n A one-line PULSE of the landed content — `\"3 ICPs · 5 personas · 2 positionings\"`, the vision's\n * own one-liner — or `null` when the family has not landed.\n \n Derived server-side from the RAW value so the list answers \"how much is in there\" without any\n * client downloading fifteen full documents. It is a COUNT-and-headline summary, never a\n * truncation of prose: a clipped sentence reads as an accident, a count reads as an answer.\n /\n contentSummary: z.string().nullable().isSummaryField(),\n /* The question this family answers, which is the axis the list groups by. /\n concern: z.enum(WorkbenchSpecificationArtifactConcern).systemEnum('WorkbenchSpecificationArtifactConcern').isSummaryField(),\n /* Landed and valid, landed and invalid, or not landed at all. /\n state: z.enum(WorkbenchSpecificationArtifactState).systemEnum('WorkbenchSpecificationArtifactState').isSummaryField(),\n /* The `_core` contract the family's content must satisfy, verbatim from the semantic authority. /\n schemaRef: z.string().min(1),\n /\n Where the family's file lives, relative to the application root — the file a reader opens when\n * the rendering is not enough.\n \n `null` when this runtime places no file for the family. A placement and a RENDER PROFILE are\n * different things (`playbook-output-landing-target`), and only the placement is asked for here.\n /\n sourcePath: z.string().min(1).nullable().isSummaryField(),\n /* ERROR-severity issues the family's own validator reports on the landed content, right now. /\n errorCount: z.number().int().nonnegative().isSummaryField(),\n /* WARN-severity issues — authoring drift that does not invalidate the artifact. /\n warnCount: z.number().int().nonnegative().isSummaryField(),\n /\n Every playbook whose declared `outputs[].family` is this family.\n \n This is the durable half of \"what produced it\": a fact about the compiled catalog, in git, true\n * whether or not any run's state survives. A link to the RUN that produced this particular value\n * was deliberately rejected — runs, traces and the write register are a per-run cache under\n * `one-source-of-truth.md` Rule 5, so a durable artifact pointing into deletable state is dangling\n * by design. The link runs the other way: a run may name what it wrote.\n \n Empty for a family no playbook produces — which is a finding, not a gap.\n /\n producedByPlaybookRefs: z.array(z.string()).isSummaryField(),\n /\n The landed family value, RAW — exactly the object the specifications package exports.\n \n ## Why the raw value rides beside its rendering\n \n The per-family presentations (workbench `artifact-presentation/`) render EDITORIALLY — an ICP\n * card, a requirement with its acceptance criteria, a placement decision with its rationale — and\n * an editorial arrangement needs the VALUE, not a markdown projection of it. The markdown\n * `document` below stays: it is the structural fallback every family keeps behind the content\n * error boundary, and the whole rendering for a family this build's vocabulary does not know.\n \n ## Untyped HERE, typed at the EDGE — a measured decision, not an omission\n \n The typed `_core` snapshot schemas live in `@wildo-ai/saas-specifications`, which depends on\n * `saas-frontend-lib` AND `saas-backend-lib` (its package.json) — while this package is the\n * platform's light contracts-only spine (`platform/CLAUDE.md`). Typing this field would drag the\n * whole engine into every consumer of this package for a shape only two consumers read. The two\n * readers type it themselves: the companion behavior validates through the semantic authority\n * before emitting, and the workbench templates narrow via TYPE-ONLY imports (erased at compile,\n * zero runtime dependency).\n \n Deliberately NOT a summary field: the LIST carries the index, and this is the heaviest thing a\n * row owns. Emitted from the RAW landed value — never from a validator's parsed output, whose\n * schema `.default()`s would inject content the author never wrote.\n /\n content: z.record(z.string(), z.unknown()).nullable(),\n /\n The artifact rendered as a document, or `null` when the family has not landed.\n \n Produced by `renderSpecificationFamilyReviewDocument` — an outline over the landed value, not a\n * prompt block. The prompt renderers (`market-render-prompt`, `brand-render-prompt`) read the same\n * content for a language model and must never be reused here.\n /\n document: z.string().nullable(),\n /\n The validator's own findings, rendered for a reader, or `null` when there are none.\n \n Carried as content rather than as counts alone because a reviewer deciding whether to accept an\n * artifact needs to see WHICH rule failed and where, and the counts beside them in the list are\n * only the signal to come and look.\n /\n issues: z.string().nullable(),\n /\n Every WARNING the validator reports, structured, one entry per finding — `[]` when there are\n * none or the family has not landed. `warnCount` is its length.\n \n Structured rather than folded into `issues` (which carries the ERRORS) so the page names them in\n * its own authored words: until 2026-09-25 only the count left the companion, and the page could say\n * \"25 warnings\" and then had to send the reader to the file to learn what they were.\n /\n warnings: z.array(Workbench_SpecificationArtifactWarning_Schema),\n /\n `DECISIONS.md` committed beside the family, verbatim, or `null` when there is none.\n \n The strongest provenance this surface has: it names the playbook that produced the artifact and,\n * more importantly, records every question the creator was asked — including the ones they did NOT\n * answer, where \"the derivation chose for itself\". A run that asked nothing writes no such file, so\n * `null` here means \"no clarification was recorded\", never \"no clarification happened\".\n /\n decisionRecord: z.string().nullable(),\n /\n `DIAGRAM.md` committed beside the family, verbatim, or `null`.\n \n Three families have one today (`domain-plan`, `build-plan`, `roadmap`). It is surfaced rather\n * than re-derived: the diagram is already a committed output of the family, regenerated on every\n * landing, and rendering a second picture here would be a second thing that can disagree with it.\n */\n diagram: z.string().nullable(),\n});\n\nexport type Workbench_SpecificationArtifact = z.infer<typeof Workbench_SpecificationArtifact_Schema>;\n"]}