@dynamicalsystems/idl 0.10.0 → 0.12.0

package/src/core/refusal.v3.ts

@@ -0,0 +1,50 @@
+// Normalized organization refusal. HTTP adapters preserve code as their
+// reason field; their transport envelopes are documented separately.
+// Dependency outages are not verdicts about a person.
+import { type Static, Type } from "@sinclair/typebox";
+import { closed, NonEmptyString, type ProfileEntry } from "../primitives.js";
+
+export const REFUSAL_V3_PROFILE = "dsg.core.refusal/3" as const;
+
+const RefusalCodeV3SchemaValue = Type.Union([
+  Type.Literal("organization_absent"),
+  Type.Literal("organization_exists"),
+  Type.Literal("domain_mismatch"),
+  Type.Literal("suspended"),
+  Type.Literal("organization_disabled"),
+  Type.Literal("claims_missing"),
+  Type.Literal("not_qualified"),
+  Type.Literal("subject_conflict"),
+]);
+export const RefusalCodeV3Schema: typeof RefusalCodeV3SchemaValue = RefusalCodeV3SchemaValue;
+export type RefusalCodeV3 = Static<typeof RefusalCodeV3Schema>;
+
+const RefusalStageV3SchemaValue = Type.Union([
+  Type.Literal("proxy"),
+  Type.Literal("provider"),
+  Type.Literal("identity_read"),
+  Type.Literal("plane"),
+  Type.Literal("console"),
+  Type.Literal("kernel"),
+  Type.Literal("record"),
+  Type.Literal("claim"),
+]);
+export const RefusalStageV3Schema: typeof RefusalStageV3SchemaValue = RefusalStageV3SchemaValue;
+export type RefusalStageV3 = Static<typeof RefusalStageV3Schema>;
+
+const RefusalV3SchemaValue = closed({
+  profile: Type.Literal(REFUSAL_V3_PROFILE),
+  code: RefusalCodeV3Schema,
+  sentence: NonEmptyString,
+  stage: Type.Optional(RefusalStageV3Schema),
+  correlationId: Type.Optional(NonEmptyString),
+  detail: Type.Optional(NonEmptyString),
+});
+export const RefusalV3Schema: typeof RefusalV3SchemaValue = RefusalV3SchemaValue;
+export type RefusalV3 = Static<typeof RefusalV3Schema>;
+
+export const refusalV3: ProfileEntry = {
+  literal: REFUSAL_V3_PROFILE,
+  rootDocument: "refusal",
+  documents: { refusal: RefusalV3Schema },
+};

package/src/index.ts

@@ -139,11 +139,50 @@ export {
 } from "./core/refusal.v2.js";
 export type { RefusalCodeV2, RefusalStageV2, RefusalV2 } from "./core/refusal.v2.js";
 export {
+  GOOGLE_IDENTITY_PROFILE,
   GOOGLE_SIGN_IN_ISSUER,
-  IDENTITY_BINDING_PROFILE,
-  IdentityBindingSchema,
-} from "./core/identity-binding.v1.js";
+  GoogleIdentitySchema,
+} from "./core/google-identity.v1.js";
+export type { GoogleIdentity } from "./core/google-identity.v1.js";
+export {
+  REFUSAL_V3_PROFILE,
+  RefusalCodeV3Schema,
+  RefusalStageV3Schema,
+  RefusalV3Schema,
+} from "./core/refusal.v3.js";
+export type { RefusalCodeV3, RefusalStageV3, RefusalV3 } from "./core/refusal.v3.js";
+export { IDENTITY_BINDING_PROFILE, IdentityBindingSchema } from "./core/identity-binding.v1.js";
 export type { IdentityBinding } from "./core/identity-binding.v1.js";
+export {
+  ORGANIZATION_SOURCE_PROFILE,
+  CapabilityOriginSchema,
+  CapabilitySelectionSchema,
+  OrganizationDocumentPathSchema,
+  OrganizationInstructionSchema,
+  OrganizationRootSchema,
+  OrganizationRootV1Schema,
+  OrganizationSourceLocationSchema,
+  OrganizationSpaceSchema,
+  ProjectMembershipSchema,
+  ProjectSourceSchema,
+  ReleaseDeclarationSchema,
+  ReleaseMemberKindSchema,
+  WorkspaceProfileSchema,
+} from "./organization/source.v2.js";
+export type {
+  CapabilityOrigin,
+  CapabilitySelection,
+  OrganizationInstruction,
+  OrganizationRoot,
+  OrganizationRootV1,
+  OrganizationSourceLocation,
+  OrganizationSourceLocationV1,
+  ProjectMembership,
+  ProjectSource,
+  ReleaseDeclaration,
+  ReleaseMemberKind,
+  WorkspaceProfile,
+} from "./organization/source.v2.js";
 
 import type { ProfileEntry } from "./primitives.js";
 import { dispatchConsumeV1 } from "./kernel/dispatch-consume.v1.js";
@@ -154,6 +193,8 @@ import { decisionV1 } from "./run/decision.v1.js";
 import { runSummaryV1 } from "./run/run-summary.v1.js";
 import { refusalV1 } from "./core/refusal.v1.js";
 import { refusalV2 } from "./core/refusal.v2.js";
+import { refusalV3 } from "./core/refusal.v3.js";
+import { googleIdentityV1 } from "./core/google-identity.v1.js";
 import { identityBindingV1 } from "./core/identity-binding.v1.js";
 import { signedLawV1 } from "./infra/signed-law.v1.js";
 import { resourceDescriptorV1 } from "./infra/resource-descriptor.v1.js";
@@ -162,12 +203,12 @@ import { revocationsV1 } from "./registry/revocations.v1.js";
 import { bootstrapV1 } from "./kernel/bootstrap.v1.js";
 import { ordinaryAuthorityV1 } from "./kernel/ordinary-authority.v1.js";
 import { standingOrderActivationV1 } from "./kernel/standing-order-activation.v1.js";
-
+import { organizationSourceV2 } from "./organization/source.v2.js";
 /** Every profile this version of the package defines, keyed by literal.
  * Profile modules are added here as they are extracted; the rules test
  * and the schema emitter walk this registry, so a module that is not
  * registered does not exist. */
-export const PROFILES: Readonly<Record<string, ProfileEntry>> = {
+export const PROFILES = {
   [dispatchConsumeV1.literal]: dispatchConsumeV1,
   [operationV1.literal]: operationV1,
   [eventV1.literal]: eventV1,
@@ -176,6 +217,8 @@ export const PROFILES: Readonly<Record<string, ProfileEntry>> = {
   [runSummaryV1.literal]: runSummaryV1,
   [refusalV1.literal]: refusalV1,
   [refusalV2.literal]: refusalV2,
+  [refusalV3.literal]: refusalV3,
+  [googleIdentityV1.literal]: googleIdentityV1,
   [identityBindingV1.literal]: identityBindingV1,
   [signedLawV1.literal]: signedLawV1,
   [resourceDescriptorV1.literal]: resourceDescriptorV1,
@@ -184,4 +227,5 @@ export const PROFILES: Readonly<Record<string, ProfileEntry>> = {
   [bootstrapV1.literal]: bootstrapV1,
   [ordinaryAuthorityV1.literal]: ordinaryAuthorityV1,
   [standingOrderActivationV1.literal]: standingOrderActivationV1,
-};
+  [organizationSourceV2.literal]: organizationSourceV2,
+} satisfies Readonly<Record<string, ProfileEntry>>;

package/src/infra/adoption-fact.v1.ts

@@ -42,6 +42,6 @@ export type AdoptionFact = Static<typeof AdoptionFactSchema>;
 
 export const adoptionFactV1: ProfileEntry = {
   literal: ADOPTION_FACT_PROFILE,
-  rootShape: "fact",
-  shapes: { fact: AdoptionFactSchema },
+  rootDocument: "fact",
+  documents: { fact: AdoptionFactSchema },
 };

package/src/infra/resource-descriptor.v1.ts

@@ -53,6 +53,6 @@ export const resourceDescriptorV1: ProfileEntry = {
   literal: RESOURCE_DESCRIPTOR_PROFILE,
   literalNote:
     "carried as kind (unversioned) plus schemaVersion on the document; the /1 literal is the version marker signed-law pins",
-  rootShape: "descriptor",
-  shapes: { descriptor: ResourceDescriptorSchema },
+  rootDocument: "descriptor",
+  documents: { descriptor: ResourceDescriptorSchema },
 };

package/src/infra/signed-law.v1.ts

@@ -273,5 +273,5 @@ export const signedLawV1: ProfileEntry = {
   literal: SIGNED_LAW_PROFILE,
   literalNote:
     "carried as the domain member of the canonical signature input, not as a bundle field",
-  shapes: { bundle: SignedLawBundleSchema },
+  documents: { bundle: SignedLawBundleSchema },
 };

package/src/kernel/bootstrap.v1.ts

@@ -64,5 +64,5 @@ export type SignedBootstrapIntent = Static<typeof SignedBootstrapIntentSchema>;
 
 export const bootstrapV1: ProfileEntry = {
   literal: BOOTSTRAP_PROFILE,
-  shapes: { intent: BootstrapIntentSchema, signed: SignedBootstrapIntentSchema },
+  documents: { intent: BootstrapIntentSchema, signed: SignedBootstrapIntentSchema },
 };

package/src/kernel/dispatch-consume.v1.ts

@@ -106,7 +106,7 @@ export type DispatchRefusal = Static<typeof DispatchRefusalSchema>;
 
 export const dispatchConsumeV1: ProfileEntry = {
   literal: DISPATCH_CONSUME_PROFILE,
-  shapes: {
+  documents: {
     request: DispatchConsumeRequestSchema,
     lease: DispatchLeaseSchema,
     refusal: DispatchRefusalSchema,

package/src/kernel/ordinary-authority.v1.ts

@@ -48,6 +48,6 @@ export type OrdinaryAuthority = Static<typeof OrdinaryAuthoritySchema>;
 
 export const ordinaryAuthorityV1: ProfileEntry = {
   literal: ORDINARY_AUTHORITY_PROFILE,
-  rootShape: "authority",
-  shapes: { authority: OrdinaryAuthoritySchema },
+  rootDocument: "authority",
+  documents: { authority: OrdinaryAuthoritySchema },
 };

package/src/kernel/standing-order-activation.v1.ts

@@ -63,8 +63,8 @@ export type SignedStandingOrderActivation = Static<typeof SignedStandingOrderAct
 
 export const standingOrderActivationV1: ProfileEntry = {
   literal: STANDING_ORDER_ACTIVATION_PROFILE,
-  rootShape: "event",
-  shapes: {
+  rootDocument: "event",
+  documents: {
     activation: StandingOrderActivationSchema,
     signed: SignedStandingOrderActivationSchema,
     event: StandingOrderActivationEventSchema,

package/src/organization/source.v2.ts

@@ -0,0 +1,219 @@
+// dsg.organization.source/2
+// Closed authoring contracts for an organization source tree. These declarations
+// describe reviewed inputs only: they contain no live principals, grants,
+// admissions, activation state, or deployment authority.
+import { type Static, Type } from "@sinclair/typebox";
+import { closed, NonEmptyString, SafeInt, type ProfileEntry } from "../primitives.js";
+
+export const ORGANIZATION_SOURCE_PROFILE = "dsg.organization.source/2" as const;
+
+export const OrganizationSpaceSchema = Type.String({
+  pattern: "^[a-z][a-z0-9-]*(?:\\.[a-z][a-z0-9-]*)+$",
+});
+
+/** A path interpreted relative to the organization source root. Filesystem
+ * containment and symlink checks belong to the consumer that opens it. */
+export const OrganizationDocumentPathSchema = Type.String({
+  minLength: 1,
+  pattern: "^(?!/)(?!.*(?:^|/)\\.\\.(?:/|$))(?!.*//)(?!.*\\\\).+$",
+});
+
+export const OrganizationSourceLocationSchema = closed({
+  repository: NonEmptyString,
+  ref: NonEmptyString,
+  subdirectory: OrganizationDocumentPathSchema,
+});
+export type OrganizationSourceLocation = Static<typeof OrganizationSourceLocationSchema>;
+const OrganizationSourceLocationV1Schema = closed({
+  repository: Type.String(),
+  ref: Type.String(),
+  subdirectory: Type.String(),
+});
+export type OrganizationSourceLocationV1 = Static<typeof OrganizationSourceLocationV1Schema>;
+
+export const ProjectSourceSchema = closed({
+  repository: NonEmptyString,
+  revision: Type.String({ pattern: "^(?:[0-9a-f]{40}|[0-9a-f]{64})$" }),
+});
+export type ProjectSource = Static<typeof ProjectSourceSchema>;
+
+const UniquePaths = () => Type.Array(OrganizationDocumentPathSchema, { uniqueItems: true });
+const UniqueNames = () => Type.Array(NonEmptyString, { uniqueItems: true });
+
+/** Frozen compatibility shape. Version one is loaded only through the explicit
+ * compatibility path; it is never silently reinterpreted as version two. */
+export const OrganizationRootV1Schema = closed({
+  schemaVersion: Type.Literal(1),
+  kind: Type.Literal("organization"),
+  org: NonEmptyString,
+  space: OrganizationSpaceSchema,
+  identity: closed({
+    principals: NonEmptyString,
+    qualifications: NonEmptyString,
+    designations: NonEmptyString,
+  }),
+  policies: NonEmptyString,
+  vocabulary: NonEmptyString,
+  admissions: NonEmptyString,
+  deployment: NonEmptyString,
+  source: Type.Optional(OrganizationSourceLocationV1Schema),
+});
+export type OrganizationRootV1 = Static<typeof OrganizationRootV1Schema>;
+
+export const OrganizationInstructionSchema = closed({
+  layer: Type.Union([
+    Type.Literal("constitution"),
+    Type.Literal("profile"),
+    Type.Literal("project"),
+  ]),
+  source: OrganizationDocumentPathSchema,
+  provenance: OrganizationDocumentPathSchema,
+});
+export type OrganizationInstruction = Static<typeof OrganizationInstructionSchema>;
+
+/** The generic root requires only stable identity, accountability, purpose and
+ * a selected profile. Optional declaration groups become required only when
+ * that profile says so. */
+export const OrganizationRootSchema = closed({
+  schemaVersion: Type.Literal(2),
+  kind: Type.Literal("organization"),
+  org: NonEmptyString,
+  space: OrganizationSpaceSchema,
+  owner: closed({
+    responsibility: NonEmptyString,
+    qualification: Type.Optional(OrganizationDocumentPathSchema),
+    designation: Type.Optional(OrganizationDocumentPathSchema),
+  }),
+  purpose: NonEmptyString,
+  profile: closed({
+    document: OrganizationDocumentPathSchema,
+    facts: Type.Record(
+      Type.String({ pattern: "^[a-z][a-z0-9-]*$" }),
+      OrganizationDocumentPathSchema,
+      { additionalProperties: false },
+    ),
+  }),
+  identity: Type.Optional(
+    closed({
+      principals: Type.Optional(OrganizationDocumentPathSchema),
+      qualifications: Type.Optional(OrganizationDocumentPathSchema),
+      designations: Type.Optional(OrganizationDocumentPathSchema),
+      eligibility: Type.Optional(OrganizationDocumentPathSchema),
+    }),
+  ),
+  policies: Type.Optional(
+    closed({
+      sources: Type.Array(OrganizationDocumentPathSchema, { minItems: 1, uniqueItems: true }),
+      release: Type.Optional(OrganizationDocumentPathSchema),
+    }),
+  ),
+  vocabulary: Type.Optional(OrganizationDocumentPathSchema),
+  admissions: Type.Optional(OrganizationDocumentPathSchema),
+  projects: Type.Optional(UniquePaths()),
+  capabilities: Type.Optional(UniquePaths()),
+  instructions: Type.Optional(Type.Array(OrganizationInstructionSchema)),
+  documents: Type.Optional(UniquePaths()),
+  archive: Type.Optional(OrganizationDocumentPathSchema),
+  releases: Type.Optional(UniquePaths()),
+  deployment: Type.Optional(OrganizationDocumentPathSchema),
+  source: Type.Optional(OrganizationSourceLocationSchema),
+});
+export type OrganizationRoot = Static<typeof OrganizationRootSchema>;
+
+export const WorkspaceProfileSchema = closed({
+  schemaVersion: Type.Literal(1),
+  kind: Type.Literal("workspace-profile"),
+  id: NonEmptyString,
+  profile: Type.Literal(ORGANIZATION_SOURCE_PROFILE),
+  version: Type.String({ pattern: "^[1-9][0-9]*\\.[0-9]+\\.[0-9]+$" }),
+  requirements: closed({
+    facts: UniqueNames(),
+    minimumProjects: SafeInt,
+    requiredCapabilities: UniqueNames(),
+    instructions: Type.Boolean(),
+  }),
+  allowedCapabilityOrigins: Type.Array(
+    Type.Union([Type.Literal("workspace"), Type.Literal("official"), Type.Literal("curated")]),
+    { uniqueItems: true },
+  ),
+  handling: closed({ required: Type.Boolean() }),
+  readinessChecks: UniquePaths(),
+});
+export type WorkspaceProfile = Static<typeof WorkspaceProfileSchema>;
+
+export const ProjectMembershipSchema = closed({
+  schemaVersion: Type.Literal(1),
+  kind: Type.Literal("project-membership"),
+  id: NonEmptyString,
+  mode: Type.Union([Type.Literal("managed"), Type.Literal("independent")]),
+  source: ProjectSourceSchema,
+  role: NonEmptyString,
+  contract: OrganizationDocumentPathSchema,
+  handling: OrganizationDocumentPathSchema,
+  state: Type.Union([Type.Literal("active"), Type.Literal("suspended"), Type.Literal("removed")]),
+});
+export type ProjectMembership = Static<typeof ProjectMembershipSchema>;
+
+export const CapabilityOriginSchema = Type.Union([
+  Type.Literal("workspace"),
+  Type.Literal("official"),
+  Type.Literal("curated"),
+]);
+export type CapabilityOrigin = Static<typeof CapabilityOriginSchema>;
+
+/** `declaration` and component `reference` point to their owning existing
+ * capability/Definition formats; this schema does not duplicate them. */
+export const CapabilitySelectionSchema = closed({
+  schemaVersion: Type.Literal(1),
+  kind: Type.Literal("capability-selection"),
+  id: NonEmptyString,
+  declaration: OrganizationDocumentPathSchema,
+  components: Type.Array(
+    closed({ id: NonEmptyString, reference: OrganizationDocumentPathSchema }),
+    { uniqueItems: true },
+  ),
+  origin: CapabilityOriginSchema,
+  dependencyLock: OrganizationDocumentPathSchema,
+  requiredDispositions: UniqueNames(),
+});
+export type CapabilitySelection = Static<typeof CapabilitySelectionSchema>;
+
+export const ReleaseMemberKindSchema = Type.Union([
+  Type.Literal("policy"),
+  Type.Literal("capability-admission"),
+  Type.Literal("workflow-publication"),
+  Type.Literal("contract-check"),
+  Type.Literal("target-readiness"),
+  Type.Literal("setup-condition"),
+]);
+export type ReleaseMemberKind = Static<typeof ReleaseMemberKindSchema>;
+
+export const ReleaseDeclarationSchema = closed({
+  schemaVersion: Type.Literal(1),
+  kind: Type.Literal("release-declaration"),
+  name: NonEmptyString,
+  selection: closed({ projects: UniqueNames(), capabilities: UniqueNames() }),
+  members: Type.Array(
+    closed({
+      key: NonEmptyString,
+      artifact: OrganizationDocumentPathSchema,
+      kind: ReleaseMemberKindSchema,
+      required: Type.Boolean(),
+      acceptableDispositions: Type.Array(NonEmptyString, { minItems: 1, uniqueItems: true }),
+    }),
+  ),
+  predecessors: UniqueNames(),
+});
+export type ReleaseDeclaration = Static<typeof ReleaseDeclarationSchema>;
+
+export const organizationSourceV2: ProfileEntry = {
+  literal: ORGANIZATION_SOURCE_PROFILE,
+  rootDocument: "organization",
+  documents: {
+    organization: OrganizationRootSchema,
+    workspaceProfile: WorkspaceProfileSchema,
+    projectMembership: ProjectMembershipSchema,
+    capabilitySelection: CapabilitySelectionSchema,
+    releaseDeclaration: ReleaseDeclarationSchema,
+  },
+};

package/src/primitives.ts

@@ -46,12 +46,12 @@ export const PersonReference = closed({
  * "lease", "refusal"); vectors address a shape as "<literal>#<shape>". */
 export type ProfileEntry = {
   readonly literal: `dsg.${string}.${string}/${number}`;
-  readonly shapes: Readonly<Record<string, TSchema>>;
+  readonly documents: Readonly<Record<string, TSchema>>;
   /** Set ONLY when the wire cannot carry the literal as a field of any
    * shape (a frozen /1); names exactly where the literal lives instead. */
   readonly literalNote?: string;
   /** Names the shape non-TS consumers validate a whole document against;
    * the emitted JSON Schema gains a root $ref to it. Only meaningful for
    * profiles with a single document root. */
-  readonly rootShape?: string;
+  readonly rootDocument?: string;
 };

package/src/registry/revocations.v1.ts

@@ -83,5 +83,5 @@ export type RevocationPointer = Static<typeof RevocationPointerSchema>;
 
 export const revocationsV1: ProfileEntry = {
   literal: REVOCATIONS_PROFILE,
-  shapes: { snapshot: RevocationSchema, pointer: RevocationPointerSchema },
+  documents: { snapshot: RevocationSchema, pointer: RevocationPointerSchema },
 };

package/src/run/decision.v1.ts

@@ -22,6 +22,6 @@ export type RunDecision = Static<typeof RunDecisionSchema>;
 
 export const decisionV1: ProfileEntry = {
   literal: DECISION_PROFILE,
-  rootShape: "decision",
-  shapes: { decision: RunDecisionSchema },
+  rootDocument: "decision",
+  documents: { decision: RunDecisionSchema },
 };

package/src/run/event.v1.ts

@@ -90,6 +90,6 @@ export type EventStreamSeal = Static<typeof EventStreamSealSchema>;
 
 export const eventV1: ProfileEntry = {
   literal: EVENT_PROFILE,
-  rootShape: "event",
-  shapes: { event: EventSchema, streamSeal: EventStreamSealSchema },
+  rootDocument: "event",
+  documents: { event: EventSchema, streamSeal: EventStreamSealSchema },
 };

package/src/run/operation.v1.ts

@@ -150,7 +150,7 @@ export type OperationStatus = Readback;
 
 export const operationV1: ProfileEntry = {
   literal: OPERATION_PROFILE,
-  shapes: {
+  documents: {
     request: OperationRequestSchema,
     accepted: AcceptedSchema,
     readback: ReadbackSchema,

package/src/run/request.v1.ts

@@ -45,6 +45,6 @@ export type RunRequest = Static<typeof RunRequestSchema>;
 
 export const requestV1: ProfileEntry = {
   literal: REQUEST_PROFILE,
-  rootShape: "request",
-  shapes: { request: RunRequestSchema },
+  rootDocument: "request",
+  documents: { request: RunRequestSchema },
 };

package/src/run/run-summary.v1.ts

@@ -37,6 +37,6 @@ export type RunSummary = Static<typeof RunSummarySchema>;
 
 export const runSummaryV1: ProfileEntry = {
   literal: RUN_SUMMARY_PROFILE,
-  rootShape: "summary",
-  shapes: { summary: RunSummarySchema },
+  rootDocument: "summary",
+  documents: { summary: RunSummarySchema },
 };