@dynamicalsystems/idl 0.11.0 → 0.13.0

package/dist/index.cjs

@@ -952,6 +952,1077 @@ const identityBindingV1 = {
 	documents: { binding: IdentityBindingSchema }
 };
 //#endregion
+//#region src/organization/source.v2.ts
+const ORGANIZATION_SOURCE_PROFILE = "dsg.organization.source/2";
+const OrganizationSpaceSchema = _sinclair_typebox.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. */
+const OrganizationDocumentPathSchema = _sinclair_typebox.Type.String({
+	minLength: 1,
+	pattern: "^(?!/)(?!.*(?:^|/)\\.\\.(?:/|$))(?!.*//)(?!.*\\\\).+$"
+});
+const OrganizationSourceLocationSchema = closed({
+	repository: NonEmptyString,
+	ref: NonEmptyString,
+	subdirectory: OrganizationDocumentPathSchema
+});
+const OrganizationSourceLocationV1Schema = closed({
+	repository: _sinclair_typebox.Type.String(),
+	ref: _sinclair_typebox.Type.String(),
+	subdirectory: _sinclair_typebox.Type.String()
+});
+const ProjectSourceSchema = closed({
+	repository: NonEmptyString,
+	revision: _sinclair_typebox.Type.String({ pattern: "^(?:[0-9a-f]{40}|[0-9a-f]{64})$" })
+});
+const UniquePaths$1 = () => _sinclair_typebox.Type.Array(OrganizationDocumentPathSchema, { uniqueItems: true });
+const UniqueNames = () => _sinclair_typebox.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. */
+const OrganizationRootV1Schema = closed({
+	schemaVersion: _sinclair_typebox.Type.Literal(1),
+	kind: _sinclair_typebox.Type.Literal("organization"),
+	org: NonEmptyString,
+	space: OrganizationSpaceSchema,
+	identity: closed({
+		principals: NonEmptyString,
+		qualifications: NonEmptyString,
+		designations: NonEmptyString
+	}),
+	policies: NonEmptyString,
+	vocabulary: NonEmptyString,
+	admissions: NonEmptyString,
+	deployment: NonEmptyString,
+	source: _sinclair_typebox.Type.Optional(OrganizationSourceLocationV1Schema)
+});
+const OrganizationInstructionSchema = closed({
+	layer: _sinclair_typebox.Type.Union([
+		_sinclair_typebox.Type.Literal("constitution"),
+		_sinclair_typebox.Type.Literal("profile"),
+		_sinclair_typebox.Type.Literal("project")
+	]),
+	source: OrganizationDocumentPathSchema,
+	provenance: OrganizationDocumentPathSchema
+});
+/** The generic root requires only stable identity, accountability, purpose and
+* a selected profile. Optional declaration groups become required only when
+* that profile says so. */
+const OrganizationRootSchema = closed({
+	schemaVersion: _sinclair_typebox.Type.Literal(2),
+	kind: _sinclair_typebox.Type.Literal("organization"),
+	org: NonEmptyString,
+	space: OrganizationSpaceSchema,
+	owner: closed({
+		responsibility: NonEmptyString,
+		qualification: _sinclair_typebox.Type.Optional(OrganizationDocumentPathSchema),
+		designation: _sinclair_typebox.Type.Optional(OrganizationDocumentPathSchema)
+	}),
+	purpose: NonEmptyString,
+	profile: closed({
+		document: OrganizationDocumentPathSchema,
+		facts: _sinclair_typebox.Type.Record(_sinclair_typebox.Type.String({ pattern: "^[a-z][a-z0-9-]*$" }), OrganizationDocumentPathSchema, { additionalProperties: false })
+	}),
+	identity: _sinclair_typebox.Type.Optional(closed({
+		principals: _sinclair_typebox.Type.Optional(OrganizationDocumentPathSchema),
+		qualifications: _sinclair_typebox.Type.Optional(OrganizationDocumentPathSchema),
+		designations: _sinclair_typebox.Type.Optional(OrganizationDocumentPathSchema),
+		eligibility: _sinclair_typebox.Type.Optional(OrganizationDocumentPathSchema)
+	})),
+	policies: _sinclair_typebox.Type.Optional(closed({
+		sources: _sinclair_typebox.Type.Array(OrganizationDocumentPathSchema, {
+			minItems: 1,
+			uniqueItems: true
+		}),
+		release: _sinclair_typebox.Type.Optional(OrganizationDocumentPathSchema)
+	})),
+	vocabulary: _sinclair_typebox.Type.Optional(OrganizationDocumentPathSchema),
+	admissions: _sinclair_typebox.Type.Optional(OrganizationDocumentPathSchema),
+	projects: _sinclair_typebox.Type.Optional(UniquePaths$1()),
+	capabilities: _sinclair_typebox.Type.Optional(UniquePaths$1()),
+	instructions: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.Array(OrganizationInstructionSchema)),
+	documents: _sinclair_typebox.Type.Optional(UniquePaths$1()),
+	archive: _sinclair_typebox.Type.Optional(OrganizationDocumentPathSchema),
+	releases: _sinclair_typebox.Type.Optional(UniquePaths$1()),
+	deployment: _sinclair_typebox.Type.Optional(OrganizationDocumentPathSchema),
+	source: _sinclair_typebox.Type.Optional(OrganizationSourceLocationSchema)
+});
+const WorkspaceProfileSchema = closed({
+	schemaVersion: _sinclair_typebox.Type.Literal(1),
+	kind: _sinclair_typebox.Type.Literal("workspace-profile"),
+	id: NonEmptyString,
+	profile: _sinclair_typebox.Type.Literal(ORGANIZATION_SOURCE_PROFILE),
+	version: _sinclair_typebox.Type.String({ pattern: "^[1-9][0-9]*\\.[0-9]+\\.[0-9]+$" }),
+	requirements: closed({
+		facts: UniqueNames(),
+		minimumProjects: SafeInt,
+		requiredCapabilities: UniqueNames(),
+		instructions: _sinclair_typebox.Type.Boolean()
+	}),
+	allowedCapabilityOrigins: _sinclair_typebox.Type.Array(_sinclair_typebox.Type.Union([
+		_sinclair_typebox.Type.Literal("workspace"),
+		_sinclair_typebox.Type.Literal("official"),
+		_sinclair_typebox.Type.Literal("curated")
+	]), { uniqueItems: true }),
+	handling: closed({ required: _sinclair_typebox.Type.Boolean() }),
+	readinessChecks: UniquePaths$1()
+});
+const ProjectMembershipSchema = closed({
+	schemaVersion: _sinclair_typebox.Type.Literal(1),
+	kind: _sinclair_typebox.Type.Literal("project-membership"),
+	id: NonEmptyString,
+	mode: _sinclair_typebox.Type.Union([_sinclair_typebox.Type.Literal("managed"), _sinclair_typebox.Type.Literal("independent")]),
+	source: ProjectSourceSchema,
+	role: NonEmptyString,
+	contract: OrganizationDocumentPathSchema,
+	handling: OrganizationDocumentPathSchema,
+	state: _sinclair_typebox.Type.Union([
+		_sinclair_typebox.Type.Literal("active"),
+		_sinclair_typebox.Type.Literal("suspended"),
+		_sinclair_typebox.Type.Literal("removed")
+	])
+});
+const CapabilityOriginSchema = _sinclair_typebox.Type.Union([
+	_sinclair_typebox.Type.Literal("workspace"),
+	_sinclair_typebox.Type.Literal("official"),
+	_sinclair_typebox.Type.Literal("curated")
+]);
+/** `declaration` and component `reference` point to their owning existing
+* capability/Definition formats; this schema does not duplicate them. */
+const CapabilitySelectionSchema = closed({
+	schemaVersion: _sinclair_typebox.Type.Literal(1),
+	kind: _sinclair_typebox.Type.Literal("capability-selection"),
+	id: NonEmptyString,
+	declaration: OrganizationDocumentPathSchema,
+	components: _sinclair_typebox.Type.Array(closed({
+		id: NonEmptyString,
+		reference: OrganizationDocumentPathSchema
+	}), { uniqueItems: true }),
+	origin: CapabilityOriginSchema,
+	dependencyLock: OrganizationDocumentPathSchema,
+	requiredDispositions: UniqueNames()
+});
+const ReleaseMemberKindSchema = _sinclair_typebox.Type.Union([
+	_sinclair_typebox.Type.Literal("policy"),
+	_sinclair_typebox.Type.Literal("capability-admission"),
+	_sinclair_typebox.Type.Literal("workflow-publication"),
+	_sinclair_typebox.Type.Literal("contract-check"),
+	_sinclair_typebox.Type.Literal("target-readiness"),
+	_sinclair_typebox.Type.Literal("setup-condition")
+]);
+const ReleaseDeclarationSchema = closed({
+	schemaVersion: _sinclair_typebox.Type.Literal(1),
+	kind: _sinclair_typebox.Type.Literal("release-declaration"),
+	name: NonEmptyString,
+	selection: closed({
+		projects: UniqueNames(),
+		capabilities: UniqueNames()
+	}),
+	members: _sinclair_typebox.Type.Array(closed({
+		key: NonEmptyString,
+		artifact: OrganizationDocumentPathSchema,
+		kind: ReleaseMemberKindSchema,
+		required: _sinclair_typebox.Type.Boolean(),
+		acceptableDispositions: _sinclair_typebox.Type.Array(NonEmptyString, {
+			minItems: 1,
+			uniqueItems: true
+		})
+	})),
+	predecessors: UniqueNames()
+});
+const organizationSourceV2 = {
+	literal: ORGANIZATION_SOURCE_PROFILE,
+	rootDocument: "organization",
+	documents: {
+		organization: OrganizationRootSchema,
+		workspaceProfile: WorkspaceProfileSchema,
+		projectMembership: ProjectMembershipSchema,
+		capabilitySelection: CapabilitySelectionSchema,
+		releaseDeclaration: ReleaseDeclarationSchema
+	}
+};
+//#endregion
+//#region src/extension/release.v1.ts
+const EXTENSION_RELEASE_PROFILE = "dsg.extension.release/1";
+const EXTENSION_RELEASE_CANONICALIZATION = "RFC8785-JCS-UTF8";
+const IdentifierSchema$1 = _sinclair_typebox.Type.String({ pattern: "^[a-z][a-z0-9-]*(?:[.-][a-z0-9]+)*$" });
+const IdentifierSet$1 = () => _sinclair_typebox.Type.Array(IdentifierSchema$1, { uniqueItems: true });
+const RequiredStrings$1 = () => _sinclair_typebox.Type.Array(NonEmptyString, {
+	minItems: 1,
+	uniqueItems: true
+});
+const ExtensionReleaseReferenceSchema = Reference;
+const ExtensionComponentKindSchema = _sinclair_typebox.Type.Union([
+	_sinclair_typebox.Type.Literal("workflow"),
+	_sinclair_typebox.Type.Literal("example"),
+	_sinclair_typebox.Type.Literal("contract"),
+	_sinclair_typebox.Type.Literal("job-class"),
+	_sinclair_typebox.Type.Literal("workload-artifact"),
+	_sinclair_typebox.Type.Literal("event-catalog"),
+	_sinclair_typebox.Type.Literal("connector"),
+	_sinclair_typebox.Type.Literal("module"),
+	_sinclair_typebox.Type.Literal("check"),
+	_sinclair_typebox.Type.Literal("vocabulary"),
+	_sinclair_typebox.Type.Literal("assurance"),
+	_sinclair_typebox.Type.Literal("documentation")
+]);
+const ExtensionComponentReferenceSchema = Reference;
+const ComponentProperties = {
+	id: IdentifierSchema$1,
+	reference: ExtensionComponentReferenceSchema,
+	mediaType: NonEmptyString,
+	required: _sinclair_typebox.Type.Boolean(),
+	dependsOn: IdentifierSet$1()
+};
+const ExtensionComponentSchema = closed({
+	...ComponentProperties,
+	kind: ExtensionComponentKindSchema
+});
+const ComputeComponentKindSchema = _sinclair_typebox.Type.Union([
+	_sinclair_typebox.Type.Literal("workflow"),
+	_sinclair_typebox.Type.Literal("example"),
+	_sinclair_typebox.Type.Literal("contract"),
+	_sinclair_typebox.Type.Literal("job-class"),
+	_sinclair_typebox.Type.Literal("workload-artifact"),
+	_sinclair_typebox.Type.Literal("event-catalog"),
+	_sinclair_typebox.Type.Literal("connector"),
+	_sinclair_typebox.Type.Literal("module"),
+	_sinclair_typebox.Type.Literal("check"),
+	_sinclair_typebox.Type.Literal("vocabulary"),
+	_sinclair_typebox.Type.Literal("assurance"),
+	_sinclair_typebox.Type.Literal("documentation")
+]);
+const ComputeComponentSchema = closed({
+	...ComponentProperties,
+	kind: ComputeComponentKindSchema
+});
+const NonComputeComponentKindSchema = _sinclair_typebox.Type.Union([
+	_sinclair_typebox.Type.Literal("workflow"),
+	_sinclair_typebox.Type.Literal("example"),
+	_sinclair_typebox.Type.Literal("contract"),
+	_sinclair_typebox.Type.Literal("event-catalog"),
+	_sinclair_typebox.Type.Literal("connector"),
+	_sinclair_typebox.Type.Literal("module"),
+	_sinclair_typebox.Type.Literal("check"),
+	_sinclair_typebox.Type.Literal("vocabulary"),
+	_sinclair_typebox.Type.Literal("assurance"),
+	_sinclair_typebox.Type.Literal("documentation")
+]);
+const NonComputeComponentSchema = closed({
+	...ComponentProperties,
+	kind: NonComputeComponentKindSchema
+});
+const ExtensionDependencyKindSchema = _sinclair_typebox.Type.Union([
+	_sinclair_typebox.Type.Literal("extension-release"),
+	_sinclair_typebox.Type.Literal("idl-package"),
+	_sinclair_typebox.Type.Literal("module-release"),
+	_sinclair_typebox.Type.Literal("law-release"),
+	_sinclair_typebox.Type.Literal("event-catalog"),
+	_sinclair_typebox.Type.Literal("example-release"),
+	_sinclair_typebox.Type.Literal("target-release")
+]);
+const ExtensionDependencySchema = closed({
+	id: IdentifierSchema$1,
+	kind: ExtensionDependencyKindSchema,
+	reference: Reference,
+	required: _sinclair_typebox.Type.Boolean()
+});
+/** Shared requirements contain no compute-only workload obligations. */
+const ExtensionRequirementsSchema = closed({
+	idlProfiles: _sinclair_typebox.Type.Array(NonEmptyString, { uniqueItems: true }),
+	roles: _sinclair_typebox.Type.Array(NonEmptyString, { uniqueItems: true }),
+	qualification: _sinclair_typebox.Type.Optional(Reference),
+	handling: _sinclair_typebox.Type.Union([
+		_sinclair_typebox.Type.Literal("public"),
+		_sinclair_typebox.Type.Literal("restricted"),
+		_sinclair_typebox.Type.Literal("confidential")
+	])
+});
+const ExtensionComputeRequirementsSchema = closed({
+	idlProfiles: _sinclair_typebox.Type.Array(NonEmptyString, { uniqueItems: true }),
+	roles: _sinclair_typebox.Type.Array(NonEmptyString, { uniqueItems: true }),
+	qualification: _sinclair_typebox.Type.Optional(Reference),
+	handling: _sinclair_typebox.Type.Union([
+		_sinclair_typebox.Type.Literal("public"),
+		_sinclair_typebox.Type.Literal("restricted"),
+		_sinclair_typebox.Type.Literal("confidential")
+	]),
+	supportedPlatforms: RequiredStrings$1(),
+	targets: _sinclair_typebox.Type.Array(Reference, { uniqueItems: true }),
+	isolation: _sinclair_typebox.Type.Union([_sinclair_typebox.Type.Literal("ephemeral"), _sinclair_typebox.Type.Literal("dedicated")]),
+	retention: _sinclair_typebox.Type.Union([
+		_sinclair_typebox.Type.Literal("ephemeral"),
+		_sinclair_typebox.Type.Literal("bounded"),
+		_sinclair_typebox.Type.Literal("durable")
+	]),
+	completion: Reference,
+	teardown: Reference,
+	evidence: Reference,
+	replay: Reference
+});
+const ExtensionBoundsSchema = closed({
+	maxDurationSeconds: SafeInt,
+	maxParallelism: SafeInt,
+	maxUsdMicroUnits: SafeInt
+});
+const ReleaseIdentity = {
+	profile: _sinclair_typebox.Type.Literal(EXTENSION_RELEASE_PROFILE),
+	schemaVersion: _sinclair_typebox.Type.Literal(1),
+	kind: _sinclair_typebox.Type.Literal("extension-release"),
+	publisher: Orn,
+	name: IdentifierSchema$1,
+	version: _sinclair_typebox.Type.String({ pattern: "^(?:0|[1-9][0-9]*)\\.[0-9]+\\.[0-9]+$" }),
+	/** Derived from publisher, namespace, name, and version; never from this
+	* body's digest, so canonical hashing has no self-reference. */
+	releaseOrn: Orn,
+	namespace: NonEmptyString,
+	source: closed({
+		repository: NonEmptyString,
+		revision: _sinclair_typebox.Type.String({ pattern: "^(?:[0-9a-f]{40}|[0-9a-f]{64})$" })
+	}),
+	build: closed({
+		provenance: Reference,
+		sourceDigest: Hex64
+	}),
+	canonicalization: _sinclair_typebox.Type.Literal(EXTENSION_RELEASE_CANONICALIZATION),
+	dependencies: _sinclair_typebox.Type.Array(ExtensionDependencySchema, { uniqueItems: true })
+};
+const ComputeReleaseSchema = closed({
+	...ReleaseIdentity,
+	compute: _sinclair_typebox.Type.Literal(true),
+	components: _sinclair_typebox.Type.Array(ComputeComponentSchema, {
+		minItems: 1,
+		uniqueItems: true
+	}),
+	requirements: ExtensionComputeRequirementsSchema,
+	bounds: ExtensionBoundsSchema
+});
+const NonComputeReleaseSchema = closed({
+	...ReleaseIdentity,
+	compute: _sinclair_typebox.Type.Literal(false),
+	components: _sinclair_typebox.Type.Array(NonComputeComponentSchema, {
+		minItems: 1,
+		uniqueItems: true
+	}),
+	requirements: ExtensionRequirementsSchema
+});
+const ExtensionReleaseSchema = _sinclair_typebox.Type.Union([ComputeReleaseSchema, NonComputeReleaseSchema]);
+/** Detached publisher envelope. `release.sha256` and `bodySha256` both pin
+* the RFC 8785 JCS UTF-8 bytes of the semantic release body. */
+const ExtensionReleaseSignatureSchema = closed({
+	profile: _sinclair_typebox.Type.Literal(EXTENSION_RELEASE_PROFILE),
+	schemaVersion: _sinclair_typebox.Type.Literal(1),
+	kind: _sinclair_typebox.Type.Literal("extension-release-signature"),
+	release: ExtensionReleaseReferenceSchema,
+	publisher: Orn,
+	publicKey: Hex64,
+	bodySha256: Hex64,
+	canonicalization: _sinclair_typebox.Type.Literal(EXTENSION_RELEASE_CANONICALIZATION),
+	signature: _sinclair_typebox.Type.String({ pattern: "^[0-9a-f]{128}$" }),
+	signedAt: UtcSecond
+});
+const extensionReleaseV1 = {
+	literal: EXTENSION_RELEASE_PROFILE,
+	rootDocument: "release",
+	documents: {
+		release: ExtensionReleaseSchema,
+		signature: ExtensionReleaseSignatureSchema
+	}
+};
+//#endregion
+//#region src/organization/release.v1.ts
+const ORGANIZATION_RELEASE_PROFILE = "dsg.organization.release/1";
+const ORGANIZATION_RELEASE_CANONICALIZATION = "RFC8785-JCS-UTF8";
+const Identifier = _sinclair_typebox.Type.String({ pattern: "^[a-z][a-z0-9-]*(?:[.-][a-z0-9]+)*$" });
+const Revision = _sinclair_typebox.Type.String({ pattern: "^(?:[0-9a-f]{40}|[0-9a-f]{64})$" });
+const Identifiers = () => _sinclair_typebox.Type.Array(Identifier, { uniqueItems: true });
+const References = () => _sinclair_typebox.Type.Array(Reference, { uniqueItems: true });
+const Evidence = () => _sinclair_typebox.Type.Array(Reference, {
+	minItems: 1,
+	uniqueItems: true
+});
+const Header = {
+	profile: _sinclair_typebox.Type.Literal(ORGANIZATION_RELEASE_PROFILE),
+	schemaVersion: _sinclair_typebox.Type.Literal(1)
+};
+const CompilerContractSchema = closed({
+	profile: _sinclair_typebox.Type.String({ pattern: "^dsg\\.[a-z0-9.-]+/[1-9][0-9]*$" }),
+	version: _sinclair_typebox.Type.String({ pattern: "^(?:0|[1-9][0-9]*)\\.(?:0|[1-9][0-9]*)\\.(?:0|[1-9][0-9]*)$" }),
+	implementation: Reference
+});
+const DependencyKindSchema = _sinclair_typebox.Type.Union([
+	_sinclair_typebox.Type.Literal("extension-release"),
+	_sinclair_typebox.Type.Literal("component"),
+	_sinclair_typebox.Type.Literal("idl-package"),
+	_sinclair_typebox.Type.Literal("module-release"),
+	_sinclair_typebox.Type.Literal("law-release"),
+	_sinclair_typebox.Type.Literal("definition"),
+	_sinclair_typebox.Type.Literal("workload-artifact"),
+	_sinclair_typebox.Type.Literal("event-catalog"),
+	_sinclair_typebox.Type.Literal("example"),
+	_sinclair_typebox.Type.Literal("project"),
+	_sinclair_typebox.Type.Literal("target")
+]);
+const DependencyLockEntrySchema = closed({
+	id: Identifier,
+	kind: DependencyKindSchema,
+	reference: Reference,
+	mediaType: NonEmptyString,
+	selectedMemberIds: Identifiers(),
+	dependsOn: Identifiers()
+});
+const DependencyLockSchema = closed({
+	...Header,
+	kind: _sinclair_typebox.Type.Literal("dependency-lock"),
+	canonicalization: _sinclair_typebox.Type.Literal(ORGANIZATION_RELEASE_CANONICALIZATION),
+	roots: Identifiers(),
+	entries: _sinclair_typebox.Type.Array(DependencyLockEntrySchema, { uniqueItems: true }),
+	compiler: CompilerContractSchema
+});
+const OrganizationReleaseMemberKindSchema = _sinclair_typebox.Type.Union([
+	_sinclair_typebox.Type.Literal("publication"),
+	_sinclair_typebox.Type.Literal("import"),
+	_sinclair_typebox.Type.Literal("capability-admission"),
+	_sinclair_typebox.Type.Literal("workflow-publication"),
+	_sinclair_typebox.Type.Literal("contract-check"),
+	_sinclair_typebox.Type.Literal("target-readiness"),
+	_sinclair_typebox.Type.Literal("setup-condition"),
+	_sinclair_typebox.Type.Literal("paid-execution-readiness")
+]);
+const OrganizationReleaseMemberSchema = closed({
+	id: Identifier,
+	kind: OrganizationReleaseMemberKindSchema,
+	required: _sinclair_typebox.Type.Boolean(),
+	acceptableDispositions: _sinclair_typebox.Type.Array(NonEmptyString, {
+		minItems: 1,
+		uniqueItems: true
+	}),
+	subject: Reference
+});
+const ComponentBindingSchema = closed({
+	id: Identifier,
+	kind: ExtensionComponentKindSchema,
+	reference: Reference
+});
+const BuildSelectionSchema = closed({
+	id: Identifier,
+	selection: Reference,
+	extensionRelease: Reference,
+	members: _sinclair_typebox.Type.Array(ComponentBindingSchema, {
+		minItems: 1,
+		uniqueItems: true
+	})
+});
+const BuildComponentSchema = closed({
+	extensionRelease: Reference,
+	memberId: Identifier,
+	kind: ExtensionComponentKindSchema,
+	reference: Reference,
+	mediaType: NonEmptyString
+});
+const OrganizationBuildSchema = closed({
+	...Header,
+	kind: _sinclair_typebox.Type.Literal("organization-build"),
+	organization: NonEmptyString,
+	canonicalization: _sinclair_typebox.Type.Literal(ORGANIZATION_RELEASE_CANONICALIZATION),
+	source: closed({
+		root: Reference,
+		revision: Revision
+	}),
+	facts: closed({
+		name: NonEmptyString,
+		purpose: NonEmptyString,
+		space: NonEmptyString
+	}),
+	workspaceProfile: Reference,
+	projects: _sinclair_typebox.Type.Array(closed({
+		id: Identifier,
+		membership: Reference,
+		revision: Revision
+	}), { uniqueItems: true }),
+	sourceDocuments: _sinclair_typebox.Type.Array(closed({
+		path: NonEmptyString,
+		sha256: Hex64,
+		mediaType: NonEmptyString
+	}), {
+		minItems: 1,
+		uniqueItems: true
+	}),
+	selections: _sinclair_typebox.Type.Array(BuildSelectionSchema, { uniqueItems: true }),
+	components: _sinclair_typebox.Type.Array(BuildComponentSchema, { uniqueItems: true }),
+	typedReleases: _sinclair_typebox.Type.Array(DependencyLockEntrySchema, { uniqueItems: true }),
+	dependencyLock: Reference,
+	compiler: CompilerContractSchema,
+	instructions: References(),
+	handling: References(),
+	releaseDeclarations: References(),
+	releaseMembers: _sinclair_typebox.Type.Array(OrganizationReleaseMemberSchema, { uniqueItems: true })
+});
+const OrganizationReleaseSchema = closed({
+	...Header,
+	kind: _sinclair_typebox.Type.Literal("organization-release"),
+	id: Identifier,
+	organization: NonEmptyString,
+	build: Reference,
+	dependencyLock: Reference,
+	selections: Identifiers(),
+	members: _sinclair_typebox.Type.Array(OrganizationReleaseMemberSchema, {
+		minItems: 1,
+		uniqueItems: true
+	})
+});
+const ImportCommon = {
+	...Header,
+	kind: _sinclair_typebox.Type.Literal("import-disposition"),
+	installation: Orn,
+	build: Reference,
+	release: Reference,
+	subject: Reference,
+	observedAt: UtcSecond
+};
+const ImportDispositionSchema = _sinclair_typebox.Type.Union([
+	closed({
+		...ImportCommon,
+		status: _sinclair_typebox.Type.Literal("pending")
+	}),
+	closed({
+		...ImportCommon,
+		status: _sinclair_typebox.Type.Literal("verified"),
+		disposition: _sinclair_typebox.Type.Union([_sinclair_typebox.Type.Literal("published"), _sinclair_typebox.Type.Literal("digest-match")]),
+		evidence: Evidence()
+	}),
+	closed({
+		...ImportCommon,
+		status: _sinclair_typebox.Type.Literal("staged"),
+		disposition: _sinclair_typebox.Type.Literal("captured"),
+		evidence: Evidence()
+	}),
+	closed({
+		...ImportCommon,
+		status: _sinclair_typebox.Type.Literal("refused"),
+		disposition: _sinclair_typebox.Type.Union([
+			_sinclair_typebox.Type.Literal("digest-mismatch"),
+			_sinclair_typebox.Type.Literal("missing"),
+			_sinclair_typebox.Type.Literal("unsupported")
+		]),
+		reason: NonEmptyString,
+		evidence: Evidence()
+	})
+]);
+const ReleaseStatusSchema = _sinclair_typebox.Type.Union([
+	_sinclair_typebox.Type.Literal("active"),
+	_sinclair_typebox.Type.Literal("retired"),
+	_sinclair_typebox.Type.Literal("revoked")
+]);
+const ReleaseStatusObservationSchema = closed({
+	...Header,
+	kind: _sinclair_typebox.Type.Literal("release-status-observation"),
+	subject: Reference,
+	registry: Reference,
+	trustView: Reference,
+	status: ReleaseStatusSchema,
+	effectiveAt: UtcSecond,
+	observedAt: UtcSecond,
+	evidence: Evidence()
+});
+const ReleaseEligibilitySchema = closed({
+	...Header,
+	kind: _sinclair_typebox.Type.Literal("release-eligibility"),
+	release: Reference,
+	operation: _sinclair_typebox.Type.Union([
+		_sinclair_typebox.Type.Literal("resolve"),
+		_sinclair_typebox.Type.Literal("select"),
+		_sinclair_typebox.Type.Literal("import"),
+		_sinclair_typebox.Type.Literal("admit"),
+		_sinclair_typebox.Type.Literal("activate"),
+		_sinclair_typebox.Type.Literal("execute")
+	]),
+	observation: ReleaseStatusObservationSchema,
+	trustView: Reference,
+	activeSet: _sinclair_typebox.Type.Union([Reference, _sinclair_typebox.Type.Null()])
+});
+const ApprovedUseSchema = closed({
+	use: NonEmptyString,
+	binding: Reference
+});
+const AdmissionCommon = {
+	...Header,
+	kind: _sinclair_typebox.Type.Literal("admission-record"),
+	id: Identifier,
+	installation: Orn,
+	organization: NonEmptyString,
+	build: Reference,
+	release: Reference,
+	selectionId: Identifier,
+	extensionRelease: Reference,
+	evaluatingCase: Reference,
+	decision: Reference,
+	authority: Reference,
+	fence: Reference,
+	revision: SafeInt,
+	decidedAt: UtcSecond
+};
+const AdmissionRecordSchema = _sinclair_typebox.Type.Union([closed({
+	...AdmissionCommon,
+	status: _sinclair_typebox.Type.Literal("admitted"),
+	components: _sinclair_typebox.Type.Array(ComponentBindingSchema, {
+		minItems: 1,
+		uniqueItems: true
+	}),
+	approvedUses: _sinclair_typebox.Type.Array(ApprovedUseSchema, {
+		minItems: 1,
+		uniqueItems: true
+	}),
+	bindings: Evidence(),
+	evidence: Evidence()
+}), closed({
+	...AdmissionCommon,
+	status: _sinclair_typebox.Type.Literal("refused"),
+	components: _sinclair_typebox.Type.Array(ComponentBindingSchema, { uniqueItems: true }),
+	reason: NonEmptyString,
+	evidence: Evidence()
+})]);
+const AdmissionObservationCommon = {
+	...Header,
+	kind: _sinclair_typebox.Type.Literal("admission-status-observation"),
+	admission: Reference,
+	decision: Reference,
+	evidence: Evidence(),
+	observedAt: UtcSecond
+};
+const AdmissionStatusObservationSchema = _sinclair_typebox.Type.Union([
+	closed({
+		...AdmissionObservationCommon,
+		status: _sinclair_typebox.Type.Literal("suspended"),
+		reason: NonEmptyString
+	}),
+	closed({
+		...AdmissionObservationCommon,
+		status: _sinclair_typebox.Type.Literal("superseded"),
+		replacement: Reference
+	}),
+	closed({
+		...AdmissionObservationCommon,
+		status: _sinclair_typebox.Type.Literal("revoked"),
+		governedRevocation: Reference,
+		trustView: Reference,
+		reason: NonEmptyString
+	})
+]);
+const MemberObservationCommon = {
+	...Header,
+	kind: _sinclair_typebox.Type.Literal("member-observation"),
+	installation: Orn,
+	build: Reference,
+	release: Reference,
+	memberId: Identifier,
+	memberKind: OrganizationReleaseMemberKindSchema,
+	subject: Reference,
+	evidence: Evidence(),
+	observedAt: UtcSecond
+};
+const MemberObservationSchema = _sinclair_typebox.Type.Union([closed({
+	...MemberObservationCommon,
+	disposition: _sinclair_typebox.Type.Union([_sinclair_typebox.Type.Literal("ready"), _sinclair_typebox.Type.Literal("verified")])
+}), closed({
+	...MemberObservationCommon,
+	disposition: _sinclair_typebox.Type.Union([
+		_sinclair_typebox.Type.Literal("refused"),
+		_sinclair_typebox.Type.Literal("suspended"),
+		_sinclair_typebox.Type.Literal("revoked")
+	]),
+	reason: NonEmptyString
+})]);
+const ActiveMemberSchema = closed({
+	selectionId: Identifier,
+	memberId: Identifier,
+	extensionRelease: Reference,
+	components: _sinclair_typebox.Type.Array(ComponentBindingSchema, {
+		minItems: 1,
+		uniqueItems: true
+	}),
+	admission: Reference
+});
+const ActiveSetSchema = closed({
+	...Header,
+	kind: _sinclair_typebox.Type.Literal("active-set"),
+	installation: Orn,
+	organization: NonEmptyString,
+	release: Reference,
+	build: Reference,
+	predecessor: _sinclair_typebox.Type.Union([Reference, _sinclair_typebox.Type.Null()]),
+	members: _sinclair_typebox.Type.Array(ActiveMemberSchema, { uniqueItems: true }),
+	memberObservations: Evidence(),
+	policies: References(),
+	configuration: References(),
+	activatingCase: Reference,
+	authority: Reference,
+	activatingDecision: Reference,
+	fence: Reference,
+	revision: SafeInt,
+	activatedAt: UtcSecond
+});
+const CatalogEntryCommon = {
+	id: Identifier,
+	activeSet: Reference,
+	selectionId: Identifier,
+	memberId: Identifier,
+	extensionRelease: Reference,
+	workflow: Reference,
+	example: _sinclair_typebox.Type.Union([Reference, _sinclair_typebox.Type.Null()]),
+	jobClass: _sinclair_typebox.Type.Union([Reference, _sinclair_typebox.Type.Null()]),
+	workloadArtifact: _sinclair_typebox.Type.Union([Reference, _sinclair_typebox.Type.Null()]),
+	contracts: References(),
+	availabilityEvidence: Evidence()
+};
+const CatalogEntrySchema = _sinclair_typebox.Type.Union([closed({
+	...CatalogEntryCommon,
+	availability: _sinclair_typebox.Type.Literal("available")
+}), closed({
+	...CatalogEntryCommon,
+	availability: _sinclair_typebox.Type.Literal("unavailable"),
+	unavailableReason: NonEmptyString
+})]);
+const CatalogSchema = closed({
+	...Header,
+	kind: _sinclair_typebox.Type.Literal("catalog"),
+	activeSet: Reference,
+	entries: _sinclair_typebox.Type.Array(CatalogEntrySchema, { uniqueItems: true })
+});
+const BoundAttestationSchema = closed({
+	...Header,
+	kind: _sinclair_typebox.Type.Literal("bound-attestation"),
+	subject: Reference,
+	issuer: Orn,
+	evidence: Reference,
+	verification: _sinclair_typebox.Type.Union([
+		_sinclair_typebox.Type.Literal("publisher-signature"),
+		_sinclair_typebox.Type.Literal("registry-recognition"),
+		_sinclair_typebox.Type.Literal("source-provenance"),
+		_sinclair_typebox.Type.Literal("component-digest")
+	]),
+	observedAt: UtcSecond,
+	signature: NonEmptyString
+});
+const organizationReleaseV1 = {
+	literal: ORGANIZATION_RELEASE_PROFILE,
+	documents: {
+		dependencyLock: DependencyLockSchema,
+		organizationBuild: OrganizationBuildSchema,
+		importDisposition: ImportDispositionSchema,
+		releaseStatusObservation: ReleaseStatusObservationSchema,
+		releaseEligibility: ReleaseEligibilitySchema,
+		organizationRelease: OrganizationReleaseSchema,
+		admissionRecord: AdmissionRecordSchema,
+		admissionStatusObservation: AdmissionStatusObservationSchema,
+		memberObservation: MemberObservationSchema,
+		activeSet: ActiveSetSchema,
+		catalog: CatalogSchema,
+		boundAttestation: BoundAttestationSchema
+	}
+};
+//#endregion
+//#region src/organization/source.v3.ts
+const ORGANIZATION_SOURCE_V3_PROFILE = "dsg.organization.source/3";
+const IdentifierSchema = _sinclair_typebox.Type.String({ pattern: "^[a-z][a-z0-9-]*(?:[.-][a-z0-9]+)*$" });
+const UniqueIdentifiers = () => _sinclair_typebox.Type.Array(IdentifierSchema, {
+	minItems: 1,
+	uniqueItems: true
+});
+const IdentifierSet = () => _sinclair_typebox.Type.Array(IdentifierSchema, { uniqueItems: true });
+const UniquePaths = () => _sinclair_typebox.Type.Array(OrganizationDocumentPathSchema, { uniqueItems: true });
+const UniqueStrings = () => _sinclair_typebox.Type.Array(NonEmptyString, { uniqueItems: true });
+const OrganizationSourceProjectSchema = closed({
+	schemaVersion: _sinclair_typebox.Type.Literal(3),
+	kind: _sinclair_typebox.Type.Literal("project-membership"),
+	id: IdentifierSchema,
+	source: ProjectSourceSchema,
+	contract: OrganizationDocumentPathSchema,
+	handling: OrganizationDocumentPathSchema
+});
+const OrganizationSelectionDispositionSchema = closed({
+	kind: _sinclair_typebox.Type.Union([
+		_sinclair_typebox.Type.Literal("publication"),
+		_sinclair_typebox.Type.Literal("import"),
+		_sinclair_typebox.Type.Literal("admission"),
+		_sinclair_typebox.Type.Literal("target"),
+		_sinclair_typebox.Type.Literal("check"),
+		_sinclair_typebox.Type.Literal("setup"),
+		_sinclair_typebox.Type.Literal("paid-execution")
+	]),
+	required: _sinclair_typebox.Type.Boolean(),
+	acceptable: UniqueStrings()
+});
+const AuthoredOverlaySchema = closed({
+	id: IdentifierSchema,
+	document: OrganizationDocumentPathSchema,
+	sha256: Hex64,
+	mediaType: NonEmptyString
+});
+const CapabilitySelectionV3Schema = closed({
+	schemaVersion: _sinclair_typebox.Type.Literal(3),
+	kind: _sinclair_typebox.Type.Literal("capability-selection"),
+	id: IdentifierSchema,
+	release: ExtensionReleaseReferenceSchema,
+	memberIds: UniqueIdentifiers(),
+	origin: _sinclair_typebox.Type.Union([
+		_sinclair_typebox.Type.Literal("workspace"),
+		_sinclair_typebox.Type.Literal("official"),
+		_sinclair_typebox.Type.Literal("curated")
+	]),
+	dependencyLock: OrganizationDocumentPathSchema,
+	requiredDispositions: _sinclair_typebox.Type.Array(OrganizationSelectionDispositionSchema, {
+		minItems: 1,
+		uniqueItems: true
+	}),
+	authoredOverlays: _sinclair_typebox.Type.Array(AuthoredOverlaySchema, { uniqueItems: true })
+});
+const WorkspaceProfileV3Schema = closed({
+	schemaVersion: _sinclair_typebox.Type.Literal(3),
+	kind: _sinclair_typebox.Type.Literal("workspace-profile"),
+	profile: _sinclair_typebox.Type.Literal(ORGANIZATION_SOURCE_V3_PROFILE),
+	id: IdentifierSchema,
+	version: _sinclair_typebox.Type.String({ pattern: "^(?:0|[1-9][0-9]*)\\.[0-9]+\\.[0-9]+$" }),
+	requirements: closed({
+		facts: UniqueStrings(),
+		minimumProjects: _sinclair_typebox.Type.Integer({ minimum: 0 }),
+		requiredSelections: _sinclair_typebox.Type.Array(IdentifierSchema, { uniqueItems: true }),
+		instructions: _sinclair_typebox.Type.Boolean()
+	}),
+	allowedOrigins: _sinclair_typebox.Type.Array(_sinclair_typebox.Type.Union([
+		_sinclair_typebox.Type.Literal("workspace"),
+		_sinclair_typebox.Type.Literal("official"),
+		_sinclair_typebox.Type.Literal("curated")
+	]), {
+		minItems: 1,
+		uniqueItems: true
+	}),
+	sourceChecks: UniquePaths()
+});
+/** A semantic dependency lock is a source document referenced by the root;
+* its lock bytes contain no Build self-reference or runtime observations. */
+const OrganizationDependencyLockSchema = DependencyLockSchema;
+const OrganizationSourceReleaseMemberSchema = closed({
+	id: IdentifierSchema,
+	kind: OrganizationReleaseMemberKindSchema,
+	required: _sinclair_typebox.Type.Boolean(),
+	acceptableDispositions: _sinclair_typebox.Type.Array(NonEmptyString, {
+		minItems: 1,
+		uniqueItems: true
+	}),
+	subject: OrganizationDocumentPathSchema
+});
+/** Source-only Organization Release declaration. Runtime status, admission,
+* activation, predecessor, and supersession belong to release records. */
+const OrganizationReleaseDeclarationSchema = closed({
+	schemaVersion: _sinclair_typebox.Type.Literal(3),
+	kind: _sinclair_typebox.Type.Literal("organization-release-declaration"),
+	id: IdentifierSchema,
+	dependencyLock: OrganizationDocumentPathSchema,
+	selections: IdentifierSet(),
+	members: _sinclair_typebox.Type.Array(OrganizationSourceReleaseMemberSchema, {
+		minItems: 1,
+		uniqueItems: true
+	}),
+	acceptance: closed({
+		requiredMembers: UniqueIdentifiers(),
+		acceptableDispositions: _sinclair_typebox.Type.Array(NonEmptyString, {
+			minItems: 1,
+			uniqueItems: true
+		})
+	})
+});
+const OrganizationRootV3Schema = closed({
+	schemaVersion: _sinclair_typebox.Type.Literal(3),
+	kind: _sinclair_typebox.Type.Literal("organization"),
+	org: NonEmptyString,
+	space: OrganizationSpaceSchema,
+	purpose: NonEmptyString,
+	profile: OrganizationDocumentPathSchema,
+	projects: UniquePaths(),
+	capabilities: UniquePaths(),
+	dependencyLocks: UniquePaths(),
+	releases: UniquePaths(),
+	instructions: UniquePaths(),
+	documents: UniquePaths(),
+	archive: _sinclair_typebox.Type.Optional(OrganizationDocumentPathSchema),
+	source: _sinclair_typebox.Type.Optional(OrganizationSourceLocationSchema)
+});
+const organizationSourceV3 = {
+	literal: ORGANIZATION_SOURCE_V3_PROFILE,
+	rootDocument: "organization",
+	documents: {
+		organization: OrganizationRootV3Schema,
+		profile: WorkspaceProfileV3Schema,
+		project: OrganizationSourceProjectSchema,
+		capabilitySelection: CapabilitySelectionV3Schema,
+		dependencyLock: OrganizationDependencyLockSchema,
+		releaseMember: OrganizationSourceReleaseMemberSchema,
+		releaseDeclaration: OrganizationReleaseDeclarationSchema
+	}
+};
+//#endregion
+//#region src/run/job-class.v1.ts
+const JOB_CLASS_PROFILE = "dsg.run.job-class/1";
+const RequiredReferences = () => _sinclair_typebox.Type.Array(Reference, {
+	minItems: 1,
+	uniqueItems: true
+});
+const RequiredStrings = () => _sinclair_typebox.Type.Array(NonEmptyString, {
+	minItems: 1,
+	uniqueItems: true
+});
+const JobClassBoundsSchema = closed({
+	maxRunSeconds: SafeInt,
+	maxGpuSeconds: SafeInt,
+	maxParallelism: SafeInt,
+	maxUsdMicroUnits: SafeInt
+});
+const JobClassSchema = closed({
+	profile: _sinclair_typebox.Type.Literal(JOB_CLASS_PROFILE),
+	schemaVersion: _sinclair_typebox.Type.Literal(1),
+	kind: _sinclair_typebox.Type.Literal("job-class"),
+	id: NonEmptyString,
+	executor: NonEmptyString,
+	mode: NonEmptyString,
+	modeEnvironmentVariable: NonEmptyString,
+	workloadArtifact: Reference,
+	platforms: RequiredStrings(),
+	isolation: _sinclair_typebox.Type.Union([_sinclair_typebox.Type.Literal("ephemeral"), _sinclair_typebox.Type.Literal("dedicated")]),
+	inputContracts: RequiredReferences(),
+	outputContracts: RequiredReferences(),
+	eventCatalog: Reference,
+	decisionRequirements: RequiredReferences(),
+	bounds: JobClassBoundsSchema,
+	handling: _sinclair_typebox.Type.Union([
+		_sinclair_typebox.Type.Literal("public"),
+		_sinclair_typebox.Type.Literal("restricted"),
+		_sinclair_typebox.Type.Literal("confidential")
+	]),
+	retention: _sinclair_typebox.Type.Union([
+		_sinclair_typebox.Type.Literal("ephemeral"),
+		_sinclair_typebox.Type.Literal("bounded"),
+		_sinclair_typebox.Type.Literal("durable")
+	]),
+	completion: Reference,
+	teardown: Reference,
+	evidence: Reference,
+	replay: Reference
+});
+const jobClassV1 = {
+	literal: JOB_CLASS_PROFILE,
+	rootDocument: "jobClass",
+	documents: { jobClass: JobClassSchema }
+};
+//#endregion
+//#region src/run/workload-artifact.v1.ts
+const WORKLOAD_ARTIFACT_PROFILE = "dsg.run.workload-artifact/1";
+const OciRepository = _sinclair_typebox.Type.String({ pattern: "^(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)*[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?::[1-9][0-9]{0,4})?/[a-z0-9]+(?:[._-][a-z0-9]+)*(?:/[a-z0-9]+(?:[._-][a-z0-9]+)*)*$" });
+const WorkloadSourceSchema = closed({
+	repository: NonEmptyString,
+	revision: _sinclair_typebox.Type.String({ pattern: "^(?:[0-9a-f]{40}|[0-9a-f]{64})$" }),
+	sourceDigest: Hex64
+});
+const OciPlatformSchema = closed({
+	os: NonEmptyString,
+	architecture: NonEmptyString,
+	variant: _sinclair_typebox.Type.Optional(NonEmptyString)
+});
+const WorkloadArtifactSchema = closed({
+	profile: _sinclair_typebox.Type.Literal(WORKLOAD_ARTIFACT_PROFILE),
+	schemaVersion: _sinclair_typebox.Type.Literal(1),
+	kind: _sinclair_typebox.Type.Literal("workload-artifact"),
+	id: NonEmptyString,
+	format: _sinclair_typebox.Type.Literal("oci-image"),
+	source: WorkloadSourceSchema,
+	index: _sinclair_typebox.Type.Union([_sinclair_typebox.Type.Null(), closed({
+		sha256: Hex64,
+		mediaType: _sinclair_typebox.Type.Union([_sinclair_typebox.Type.Literal("application/vnd.oci.image.index.v1+json"), _sinclair_typebox.Type.Literal("application/vnd.docker.distribution.manifest.list.v2+json")])
+	})]),
+	executable: closed({
+		repository: OciRepository,
+		platform: OciPlatformSchema,
+		manifest: closed({
+			sha256: Hex64,
+			mediaType: _sinclair_typebox.Type.Union([_sinclair_typebox.Type.Literal("application/vnd.oci.image.manifest.v1+json"), _sinclair_typebox.Type.Literal("application/vnd.docker.distribution.manifest.v2+json")])
+		}),
+		config: closed({
+			sha256: Hex64,
+			mediaType: _sinclair_typebox.Type.Union([_sinclair_typebox.Type.Literal("application/vnd.oci.image.config.v1+json"), _sinclair_typebox.Type.Literal("application/vnd.docker.container.image.v1+json")])
+		})
+	}),
+	entrypoint: _sinclair_typebox.Type.Array(NonEmptyString, { minItems: 1 })
+});
+const WorkloadArtifactProvenanceSchema = closed({
+	profile: _sinclair_typebox.Type.Literal(WORKLOAD_ARTIFACT_PROFILE),
+	schemaVersion: _sinclair_typebox.Type.Literal(1),
+	kind: _sinclair_typebox.Type.Literal("workload-artifact-provenance"),
+	artifact: Reference,
+	source: WorkloadSourceSchema,
+	build: Reference,
+	transportArchiveSha256: Hex64,
+	observedAt: UtcSecond,
+	evidence: _sinclair_typebox.Type.Array(Reference, {
+		minItems: 1,
+		uniqueItems: true
+	})
+});
+const workloadArtifactV1 = {
+	literal: WORKLOAD_ARTIFACT_PROFILE,
+	rootDocument: "workloadArtifact",
+	documents: {
+		workloadArtifact: WorkloadArtifactSchema,
+		provenance: WorkloadArtifactProvenanceSchema
+	}
+};
+//#endregion
+//#region src/run/execution-binding.v1.ts
+const EXECUTION_BINDING_PROFILE = "dsg.run.execution-binding/1";
+const ExecutionBindingSchema = closed({
+	profile: _sinclair_typebox.Type.Literal(EXECUTION_BINDING_PROFILE),
+	schemaVersion: _sinclair_typebox.Type.Literal(1),
+	kind: _sinclair_typebox.Type.Literal("execution-binding"),
+	installation: Orn,
+	operation: Reference,
+	activeSet: Reference,
+	admission: Reference,
+	organizationRelease: Reference,
+	organizationBuild: Reference,
+	selection: Reference,
+	extensionRelease: Reference,
+	workflow: Reference,
+	jobClass: Reference,
+	workloadArtifact: Reference,
+	executableManifestSha256: Hex64,
+	target: Reference,
+	eventCatalog: Reference,
+	law: Reference,
+	reservation: Reference,
+	trustView: Reference
+});
+const ExecutionRequestEnvelopeSchema = closed({
+	profile: _sinclair_typebox.Type.Literal(EXECUTION_BINDING_PROFILE),
+	schemaVersion: _sinclair_typebox.Type.Literal(1),
+	kind: _sinclair_typebox.Type.Literal("execution-request-envelope"),
+	operation: OperationRequestSchema,
+	binding: ExecutionBindingSchema,
+	jobClass: JobClassSchema,
+	workloadArtifact: WorkloadArtifactSchema,
+	workloadArtifactProvenance: WorkloadArtifactProvenanceSchema,
+	admission: AdmissionRecordSchema,
+	activeSet: ActiveSetSchema,
+	selection: BuildSelectionSchema,
+	catalogEntry: CatalogEntrySchema,
+	releaseEligibility: ReleaseEligibilitySchema
+});
+const executionBindingV1 = {
+	literal: EXECUTION_BINDING_PROFILE,
+	rootDocument: "executionBinding",
+	documents: {
+		executionBinding: ExecutionBindingSchema,
+		executionRequestEnvelope: ExecutionRequestEnvelopeSchema
+	}
+};
+//#endregion
 //#region src/index.ts
 /** Every profile this version of the package defines, keyed by literal.
 * Profile modules are added here as they are extracted; the rules test
@@ -975,41 +2046,93 @@ const PROFILES = {
 	[revocationsV1.literal]: revocationsV1,
 	[bootstrapV1.literal]: bootstrapV1,
 	[ordinaryAuthorityV1.literal]: ordinaryAuthorityV1,
-	[standingOrderActivationV1.literal]: standingOrderActivationV1
+	[standingOrderActivationV1.literal]: standingOrderActivationV1,
+	[organizationSourceV2.literal]: organizationSourceV2,
+	[extensionReleaseV1.literal]: extensionReleaseV1,
+	[organizationSourceV3.literal]: organizationSourceV3,
+	[organizationReleaseV1.literal]: organizationReleaseV1,
+	[jobClassV1.literal]: jobClassV1,
+	[workloadArtifactV1.literal]: workloadArtifactV1,
+	[executionBindingV1.literal]: executionBindingV1
 };
 //#endregion
 exports.ADOPTION_FACT_PROFILE = ADOPTION_FACT_PROFILE;
 exports.AcceptedSchema = AcceptedSchema;
+exports.ActiveMemberSchema = ActiveMemberSchema;
+exports.ActiveSetSchema = ActiveSetSchema;
+exports.AdmissionRecordSchema = AdmissionRecordSchema;
+exports.AdmissionStatusObservationSchema = AdmissionStatusObservationSchema;
 exports.AdoptionFactSchema = AdoptionFactSchema;
+exports.ApprovedUseSchema = ApprovedUseSchema;
+exports.AuthoredOverlaySchema = AuthoredOverlaySchema;
 exports.BOOTSTRAP_PROFILE = BOOTSTRAP_PROFILE;
 exports.BootstrapActionSchema = BootstrapActionSchema;
 exports.BootstrapIntentSchema = BootstrapIntentSchema;
+exports.BoundAttestationSchema = BoundAttestationSchema;
+exports.BuildComponentSchema = BuildComponentSchema;
+exports.BuildSelectionSchema = BuildSelectionSchema;
+exports.CapabilityOriginSchema = CapabilityOriginSchema;
+exports.CapabilitySelectionSchema = CapabilitySelectionSchema;
+exports.CapabilitySelectionV3Schema = CapabilitySelectionV3Schema;
+exports.CatalogEntrySchema = CatalogEntrySchema;
+exports.CatalogSchema = CatalogSchema;
+exports.CompilerContractSchema = CompilerContractSchema;
+exports.ComponentBindingSchema = ComponentBindingSchema;
 exports.DECISION_PROFILE = DECISION_PROFILE;
 exports.DISPATCH_CONSUME_PROFILE = DISPATCH_CONSUME_PROFILE;
 exports.DISPATCH_MAX_SKEW_SECONDS = DISPATCH_MAX_SKEW_SECONDS;
+exports.DependencyKindSchema = DependencyKindSchema;
+exports.DependencyLockEntrySchema = DependencyLockEntrySchema;
+exports.DependencyLockSchema = DependencyLockSchema;
 exports.DispatchConsumeRequestSchema = DispatchConsumeRequestSchema;
 exports.DispatchLeaseSchema = DispatchLeaseSchema;
 exports.DispatchRefusalCodeSchema = DispatchRefusalCodeSchema;
 exports.DispatchRefusalSchema = DispatchRefusalSchema;
 exports.EVENT_LINE_PREFIX = EVENT_LINE_PREFIX;
 exports.EVENT_PROFILE = EVENT_PROFILE;
+exports.EXECUTION_BINDING_PROFILE = EXECUTION_BINDING_PROFILE;
 exports.EXECUTOR_PROTOCOL_VERSION = EXECUTOR_PROTOCOL_VERSION;
+exports.EXTENSION_RELEASE_CANONICALIZATION = EXTENSION_RELEASE_CANONICALIZATION;
+exports.EXTENSION_RELEASE_PROFILE = EXTENSION_RELEASE_PROFILE;
 exports.EventSchema = EventSchema;
 exports.EventStreamSealSchema = EventStreamSealSchema;
+exports.ExecutionBindingSchema = ExecutionBindingSchema;
 exports.ExecutionDocumentSchema = ExecutionDocumentSchema;
 exports.ExecutionLawSchema = ExecutionLawSchema;
+exports.ExecutionRequestEnvelopeSchema = ExecutionRequestEnvelopeSchema;
 exports.ExecutionResourcesSchema = ExecutionResourcesSchema;
 exports.ExperimentRefSchema = ExperimentRefSchema;
+exports.ExtensionBoundsSchema = ExtensionBoundsSchema;
+exports.ExtensionComponentKindSchema = ExtensionComponentKindSchema;
+exports.ExtensionComponentReferenceSchema = ExtensionComponentReferenceSchema;
+exports.ExtensionComponentSchema = ExtensionComponentSchema;
+exports.ExtensionComputeRequirementsSchema = ExtensionComputeRequirementsSchema;
+exports.ExtensionDependencyKindSchema = ExtensionDependencyKindSchema;
+exports.ExtensionDependencySchema = ExtensionDependencySchema;
+exports.ExtensionReleaseReferenceSchema = ExtensionReleaseReferenceSchema;
+exports.ExtensionReleaseSchema = ExtensionReleaseSchema;
+exports.ExtensionReleaseSignatureSchema = ExtensionReleaseSignatureSchema;
+exports.ExtensionRequirementsSchema = ExtensionRequirementsSchema;
 exports.GOOGLE_IDENTITY_PROFILE = GOOGLE_IDENTITY_PROFILE;
 exports.GOOGLE_SIGN_IN_ISSUER = GOOGLE_SIGN_IN_ISSUER;
 exports.GoogleIdentitySchema = GoogleIdentitySchema;
 exports.Hex64 = Hex64;
 exports.IDENTITY_BINDING_PROFILE = IDENTITY_BINDING_PROFILE;
 exports.IdentityBindingSchema = IdentityBindingSchema;
+exports.ImportDispositionSchema = ImportDispositionSchema;
+exports.JOB_CLASS_PROFILE = JOB_CLASS_PROFILE;
+exports.JobClassBoundsSchema = JobClassBoundsSchema;
+exports.JobClassSchema = JobClassSchema;
 exports.LIFECYCLE_KINDS = LIFECYCLE_KINDS;
+exports.MemberObservationSchema = MemberObservationSchema;
 exports.NonEmptyString = NonEmptyString;
 exports.OPERATION_PROFILE = OPERATION_PROFILE;
 exports.ORDINARY_AUTHORITY_PROFILE = ORDINARY_AUTHORITY_PROFILE;
+exports.ORGANIZATION_RELEASE_CANONICALIZATION = ORGANIZATION_RELEASE_CANONICALIZATION;
+exports.ORGANIZATION_RELEASE_PROFILE = ORGANIZATION_RELEASE_PROFILE;
+exports.ORGANIZATION_SOURCE_PROFILE = ORGANIZATION_SOURCE_PROFILE;
+exports.ORGANIZATION_SOURCE_V3_PROFILE = ORGANIZATION_SOURCE_V3_PROFILE;
+exports.OciPlatformSchema = OciPlatformSchema;
 exports.OperationBeforeSchema = OperationBeforeSchema;
 exports.OperationCleanupSchema = OperationCleanupSchema;
 exports.OperationCostSchema = OperationCostSchema;
@@ -1018,11 +2141,29 @@ exports.OperationExecutionSchema = OperationExecutionSchema;
 exports.OperationRequestSchema = OperationRequestSchema;
 exports.OperationStatusSchema = OperationStatusSchema;
 exports.OrdinaryAuthoritySchema = OrdinaryAuthoritySchema;
+exports.OrganizationBuildSchema = OrganizationBuildSchema;
+exports.OrganizationDependencyLockSchema = OrganizationDependencyLockSchema;
+exports.OrganizationDocumentPathSchema = OrganizationDocumentPathSchema;
+exports.OrganizationInstructionSchema = OrganizationInstructionSchema;
+exports.OrganizationReleaseDeclarationSchema = OrganizationReleaseDeclarationSchema;
+exports.OrganizationReleaseMemberKindSchema = OrganizationReleaseMemberKindSchema;
+exports.OrganizationReleaseMemberSchema = OrganizationReleaseMemberSchema;
+exports.OrganizationReleaseSchema = OrganizationReleaseSchema;
+exports.OrganizationRootSchema = OrganizationRootSchema;
+exports.OrganizationRootV1Schema = OrganizationRootV1Schema;
+exports.OrganizationRootV3Schema = OrganizationRootV3Schema;
+exports.OrganizationSelectionDispositionSchema = OrganizationSelectionDispositionSchema;
+exports.OrganizationSourceLocationSchema = OrganizationSourceLocationSchema;
+exports.OrganizationSourceProjectSchema = OrganizationSourceProjectSchema;
+exports.OrganizationSourceReleaseMemberSchema = OrganizationSourceReleaseMemberSchema;
+exports.OrganizationSpaceSchema = OrganizationSpaceSchema;
 exports.Orn = Orn;
 exports.PRICE_PROFILE_REFERENCE = PRICE_PROFILE_REFERENCE;
 exports.PROFILES = PROFILES;
 exports.PROVIDER_PROTOCOL_VERSION = PROVIDER_PROTOCOL_VERSION;
 exports.PersonReference = PersonReference;
+exports.ProjectMembershipSchema = ProjectMembershipSchema;
+exports.ProjectSourceSchema = ProjectSourceSchema;
 exports.REFUSAL_PROFILE = REFUSAL_PROFILE;
 exports.REFUSAL_V2_PROFILE = REFUSAL_V2_PROFILE;
 exports.REFUSAL_V3_PROFILE = REFUSAL_V3_PROFILE;
@@ -1041,6 +2182,11 @@ exports.RefusalStageV2Schema = RefusalStageV2Schema;
 exports.RefusalStageV3Schema = RefusalStageV3Schema;
 exports.RefusalV2Schema = RefusalV2Schema;
 exports.RefusalV3Schema = RefusalV3Schema;
+exports.ReleaseDeclarationSchema = ReleaseDeclarationSchema;
+exports.ReleaseEligibilitySchema = ReleaseEligibilitySchema;
+exports.ReleaseMemberKindSchema = ReleaseMemberKindSchema;
+exports.ReleaseStatusObservationSchema = ReleaseStatusObservationSchema;
+exports.ReleaseStatusSchema = ReleaseStatusSchema;
 exports.RequestCeilingsSchema = RequestCeilingsSchema;
 exports.ResourceDescriptorSchema = ResourceDescriptorSchema;
 exports.RevocationPointerSchema = RevocationPointerSchema;
@@ -1062,4 +2208,10 @@ exports.StandingOrderActivationEventSchema = StandingOrderActivationEventSchema;
 exports.StandingOrderActivationSchema = StandingOrderActivationSchema;
 exports.StandingOrderModeSchema = StandingOrderModeSchema;
 exports.UtcSecond = UtcSecond;
+exports.WORKLOAD_ARTIFACT_PROFILE = WORKLOAD_ARTIFACT_PROFILE;
+exports.WorkloadArtifactProvenanceSchema = WorkloadArtifactProvenanceSchema;
+exports.WorkloadArtifactSchema = WorkloadArtifactSchema;
+exports.WorkloadSourceSchema = WorkloadSourceSchema;
+exports.WorkspaceProfileSchema = WorkspaceProfileSchema;
+exports.WorkspaceProfileV3Schema = WorkspaceProfileV3Schema;
 exports.closed = closed;