nl2data-admin-service 0.1.0__tar.gz

nl2data_admin_service-0.1.0/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: nl2data-admin-service
+Version: 0.1.0
+Summary: Optional transport-neutral admin control-plane service for the nl2data-core metadata-to-Bundle lifecycle.
+Author: NL2Data Contributors
+License: Apache-2.0
+Keywords: nl2data,admin,service,semantic catalog,metadata
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: nl2data-core>=0.1.0
+Requires-Dist: pydantic<3,>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: mypy>=1.10; extra == "dev"
+Requires-Dist: ruff>=0.5; extra == "dev"
+
+# nl2data-admin-service
+
+Optional transport-neutral admin control-plane service for the nl2data-core metadata-to-Bundle lifecycle.
+
+## Overview
+
+This package exposes a framework-neutral application service that hosts can wrap with their chosen transport (HTTP, CLI, UI, etc.). It intentionally has no HTTP, web-framework, authentication, or database-driver dependencies, keeping `nl2data` and `nl2data_core` transport-free and embeddable.
+
+## Installation
+
+```bash
+pip install -e packages/nl2data-admin-service
+```
+
+## Usage
+
+```python
+from nl2data_admin_service import AdminService, AdminServiceConfig
+from nl2data_admin_service.auth import AuthContext, Permission
+
+# Host provides dependencies and authentication context.
+service = AdminService(dependencies, AdminServiceConfig())
+context = AuthContext(
+    operator_id="operator-1",
+    tenant_scope_fingerprint="sha256:...",
+    permissions=frozenset([Permission.SNAPSHOT_READ]),
+)
+snapshot = service.get_snapshot("sha256:...", auth_context=context)
+```
+
+## Design
+
+- **Transport-neutral**: Service methods accept and return bounded Pydantic DTOs.
+- **Host-owned authentication**: The host supplies a trusted `AuthContext`; the service fails closed when it is missing.
+- **Tenant/source scoped**: Every read and mutation is scoped by the host-provided tenant/source fingerprint.
+- **Safe projection**: DTOs expose only opaque identifiers, fingerprints, versions, and bounded provenance.
+- **Idempotent**: Mutating commands require an idempotency key and expected fingerprints/revisions.
+
+## Assembly lifecycle
+
+The service projects the core lifecycle without reimplementing it:
+
+1. `create_draft(...)` or `create_draft_from_proposals(...)` creates an
+    `AssemblyDraft` in `draft` state. Draft DTOs expose state, assertion counts,
+    safe payload hashes, provenance kinds, redacted deployment-reference schemes,
+    and `draft_revision`, but no Bundle fingerprint.
+2. `submit_draft_for_review(...)` moves the draft to `review`.
+    `decide_draft_assertion(...)` approves, rejects, or edits one assertion; each
+    mutation requires the current revision, and payload edits invalidate review.
+3. `approve_assembly_draft(...)` freezes a fully reviewed draft in `approved`.
+4. `publish_draft(...)` delegates verification, publish-time fingerprinting,
+    accepted-assertion manifest derivation, audit creation, idempotency, and
+    supersession to core/catalog. Direct `publish_bundle(...)` is rejected.
+5. `activate_published_fingerprint(...)` and
+    `rollback_published_fingerprint(...)` move the active pointer among immutable
+    publications. `list_published_versions(...)` reports `available`, `active`,
+    `superseded`, `deprecated`, and `retired` state with predecessor/successor and
+    audit references.
+
+Lifecycle mutations require both the matching `Permission` and a trusted
+host-authorized Author, Reviewer, Approver, or Publisher role. Draft revision
+conflicts return normalized `conflict`; missing roles return
+`authorization_denied`. Publish outcomes contain bounded issue codes and safe
+references only, never assertion payloads, resolved connections, or raw operator
+identities.
+
+## Verification Suite
+
+`await verify_draft(...)` requires `assembly:verify`, an expected draft revision,
+and a configured policy profile. The host supplies the trusted verification
+executor and candidate-bound execution-context factory. Verification may use
+temporary fixtures and ephemeral secret resolution, but it does not mutate the
+draft, approval state, catalog, or active pointer.
+
+Planned publication uses `PublishDraftCommand` with the selected policy and
+fresh `VerificationSuiteEvidence`. The service passes those bindings to core;
+it does not reinterpret skipped, unavailable, timed-out, failed, or not-run
+outcomes. `get_verification_evidence(...)` requires `assembly:audit` and returns
+only bounded suite/layer/case statuses, counts, issue codes, identities, and
+fingerprints. Queries, observations, expected or actual values, physical names,
+deployment references, credentials, and backend exceptions never enter Admin
+result DTOs.
+
+## Semantic authoring
+
+`validate_authoring(...)` accepts `AuthoringDocumentCommand`, requires
+`bundle:validate` permission and authorized source scope, and returns only a
+bounded semantic summary or safe source-located diagnostics. It never reads or
+writes the draft store.
+
+`import_authoring(...)` accepts `ImportAuthoringCommand`, requires
+`assembly:write` permission plus the trusted `author` lifecycle role, derives
+the author reference from `AuthContext`, and persists through `create_draft`.
+Imported assertions always begin pending in a revision-zero `draft`; authoring
+cannot review, approve, publish, or activate content.
+
+Capabilities advertise the supported authoring API version and effective
+maximum input size. The built-in limit is 1 MiB and may be reduced by
+`AdminServiceConfig.max_body_size_bytes`.
+
+## Service Contract Versioning
+
+The service exposes a versioned command/result schema via `nl2data_admin_service.schema.build_schema(contract_version)`. Host transports can introspect this schema to bind requests and responses without hard-coding DTO shapes.

nl2data_admin_service-0.1.0/README.md

@@ -0,0 +1,103 @@
+# nl2data-admin-service
+
+Optional transport-neutral admin control-plane service for the nl2data-core metadata-to-Bundle lifecycle.
+
+## Overview
+
+This package exposes a framework-neutral application service that hosts can wrap with their chosen transport (HTTP, CLI, UI, etc.). It intentionally has no HTTP, web-framework, authentication, or database-driver dependencies, keeping `nl2data` and `nl2data_core` transport-free and embeddable.
+
+## Installation
+
+```bash
+pip install -e packages/nl2data-admin-service
+```
+
+## Usage
+
+```python
+from nl2data_admin_service import AdminService, AdminServiceConfig
+from nl2data_admin_service.auth import AuthContext, Permission
+
+# Host provides dependencies and authentication context.
+service = AdminService(dependencies, AdminServiceConfig())
+context = AuthContext(
+    operator_id="operator-1",
+    tenant_scope_fingerprint="sha256:...",
+    permissions=frozenset([Permission.SNAPSHOT_READ]),
+)
+snapshot = service.get_snapshot("sha256:...", auth_context=context)
+```
+
+## Design
+
+- **Transport-neutral**: Service methods accept and return bounded Pydantic DTOs.
+- **Host-owned authentication**: The host supplies a trusted `AuthContext`; the service fails closed when it is missing.
+- **Tenant/source scoped**: Every read and mutation is scoped by the host-provided tenant/source fingerprint.
+- **Safe projection**: DTOs expose only opaque identifiers, fingerprints, versions, and bounded provenance.
+- **Idempotent**: Mutating commands require an idempotency key and expected fingerprints/revisions.
+
+## Assembly lifecycle
+
+The service projects the core lifecycle without reimplementing it:
+
+1. `create_draft(...)` or `create_draft_from_proposals(...)` creates an
+    `AssemblyDraft` in `draft` state. Draft DTOs expose state, assertion counts,
+    safe payload hashes, provenance kinds, redacted deployment-reference schemes,
+    and `draft_revision`, but no Bundle fingerprint.
+2. `submit_draft_for_review(...)` moves the draft to `review`.
+    `decide_draft_assertion(...)` approves, rejects, or edits one assertion; each
+    mutation requires the current revision, and payload edits invalidate review.
+3. `approve_assembly_draft(...)` freezes a fully reviewed draft in `approved`.
+4. `publish_draft(...)` delegates verification, publish-time fingerprinting,
+    accepted-assertion manifest derivation, audit creation, idempotency, and
+    supersession to core/catalog. Direct `publish_bundle(...)` is rejected.
+5. `activate_published_fingerprint(...)` and
+    `rollback_published_fingerprint(...)` move the active pointer among immutable
+    publications. `list_published_versions(...)` reports `available`, `active`,
+    `superseded`, `deprecated`, and `retired` state with predecessor/successor and
+    audit references.
+
+Lifecycle mutations require both the matching `Permission` and a trusted
+host-authorized Author, Reviewer, Approver, or Publisher role. Draft revision
+conflicts return normalized `conflict`; missing roles return
+`authorization_denied`. Publish outcomes contain bounded issue codes and safe
+references only, never assertion payloads, resolved connections, or raw operator
+identities.
+
+## Verification Suite
+
+`await verify_draft(...)` requires `assembly:verify`, an expected draft revision,
+and a configured policy profile. The host supplies the trusted verification
+executor and candidate-bound execution-context factory. Verification may use
+temporary fixtures and ephemeral secret resolution, but it does not mutate the
+draft, approval state, catalog, or active pointer.
+
+Planned publication uses `PublishDraftCommand` with the selected policy and
+fresh `VerificationSuiteEvidence`. The service passes those bindings to core;
+it does not reinterpret skipped, unavailable, timed-out, failed, or not-run
+outcomes. `get_verification_evidence(...)` requires `assembly:audit` and returns
+only bounded suite/layer/case statuses, counts, issue codes, identities, and
+fingerprints. Queries, observations, expected or actual values, physical names,
+deployment references, credentials, and backend exceptions never enter Admin
+result DTOs.
+
+## Semantic authoring
+
+`validate_authoring(...)` accepts `AuthoringDocumentCommand`, requires
+`bundle:validate` permission and authorized source scope, and returns only a
+bounded semantic summary or safe source-located diagnostics. It never reads or
+writes the draft store.
+
+`import_authoring(...)` accepts `ImportAuthoringCommand`, requires
+`assembly:write` permission plus the trusted `author` lifecycle role, derives
+the author reference from `AuthContext`, and persists through `create_draft`.
+Imported assertions always begin pending in a revision-zero `draft`; authoring
+cannot review, approve, publish, or activate content.
+
+Capabilities advertise the supported authoring API version and effective
+maximum input size. The built-in limit is 1 MiB and may be reduced by
+`AdminServiceConfig.max_body_size_bytes`.
+
+## Service Contract Versioning
+
+The service exposes a versioned command/result schema via `nl2data_admin_service.schema.build_schema(contract_version)`. Host transports can introspect this schema to bind requests and responses without hard-coding DTO shapes.

nl2data_admin_service-0.1.0/pyproject.toml

@@ -0,0 +1,56 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "nl2data-admin-service"
+version = "0.1.0"
+description = "Optional transport-neutral admin control-plane service for the nl2data-core metadata-to-Bundle lifecycle."
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "Apache-2.0" }
+authors = [{ name = "NL2Data Contributors" }]
+keywords = ["nl2data", "admin", "service", "semantic catalog", "metadata"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = [
+    "nl2data-core>=0.1.0",
+    "pydantic>=2.0,<3",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.23",
+    "mypy>=1.10",
+    "ruff>=0.5",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.mypy]
+python_version = "3.11"
+files = ["src"]
+mypy_path = ["../../src"]
+check_untyped_defs = true
+disallow_untyped_defs = true
+no_implicit_optional = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+warn_return_any = true
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+src = ["src", "tests"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM"]

nl2data_admin_service-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

nl2data_admin_service-0.1.0/src/nl2data_admin_service/__init__.py

@@ -0,0 +1,21 @@
+"""Optional transport-neutral admin control-plane service for nl2data-core.
+
+The ``nl2data-admin-service`` package exposes a framework-neutral application
+service for the metadata-to-Bundle lifecycle.  It intentionally has no HTTP,
+authentication, web-framework, or database-driver dependencies so that hosts
+can wrap it in their chosen transport (HTTP/CLI/UI) without coupling core to
+any transport technology.
+"""
+
+from __future__ import annotations
+
+from .config import AdminServiceConfig, AdminServiceProfile
+from .protocols import AuthoringAdminService
+from .service import AdminService
+
+__all__ = [
+	"AdminService",
+	"AdminServiceConfig",
+	"AdminServiceProfile",
+	"AuthoringAdminService",
+]

nl2data_admin_service-0.1.0/src/nl2data_admin_service/assembly_admin.py

@@ -0,0 +1,358 @@
+"""Assembly draft lifecycle Admin capability service."""
+
+from __future__ import annotations
+
+from nl2data_core.assembly import (
+    AssemblyDraft,
+    AssemblyState,
+    AssertionProvenance,
+    AssertionProvenanceKind,
+    DeploymentBinding,
+    LifecycleAction,
+    LifecycleRole,
+    ReviewState,
+    SemanticAssertion,
+    require_lifecycle_authorization,
+)
+from nl2data_core.assembly import approve_draft as core_approve_draft
+from nl2data_core.assembly import create_discovery_draft as core_create_discovery_draft
+from nl2data_core.assembly import decide_assertion as core_decide_assertion
+from nl2data_core.assembly import edit_assertion as core_edit_assertion
+from nl2data_core.assembly import submit_for_review as core_submit_for_review
+
+from .auth import AuthContext, Permission
+from .common import (
+    AdminDependencyAccess,
+    lifecycle_context,
+    load_draft,
+    require_permission,
+    require_source,
+    store_draft,
+)
+from .common import (
+    normalize_errors as _normalize_errors,
+)
+from .config import AdminServiceConfig
+from .dtos import (
+    AssemblyAssertionSummary,
+    AssemblyDraftDetail,
+    AssemblyDraftSummary,
+    AssertionDecisionAction,
+    AssertionDecisionCommand,
+    DeploymentBindingSummary,
+    DraftMutationResult,
+    DraftRevisionCommand,
+)
+from .errors import ConflictError, NotFoundError, ValidationError
+from .protocols import AdminServiceDependencies
+
+
+def _draft_to_summary(draft: AssemblyDraft) -> AssemblyDraftSummary:
+    states = [assertion.review_state for assertion in draft.assertions]
+    return AssemblyDraftSummary(
+        draft_id=draft.draft_id,
+        bundle_id=draft.bundle_id,
+        model_version=draft.model_version,
+        state=draft.state.value,
+        draft_revision=draft.draft_revision,
+        assertion_count=len(draft.assertions),
+        pending_count=states.count(ReviewState.PENDING),
+        approved_count=states.count(ReviewState.APPROVED),
+        rejected_count=states.count(ReviewState.REJECTED),
+    )
+
+
+def _draft_to_detail(draft: AssemblyDraft) -> AssemblyDraftDetail:
+    summary = _draft_to_summary(draft)
+    return AssemblyDraftDetail(
+        **summary.model_dump(),
+        assertions=tuple(
+            AssemblyAssertionSummary(
+                assertion_id=assertion.id,
+                assertion_type=assertion.type.value,
+                review_state=assertion.review_state.value,
+                payload_hash=assertion.payload_hash(),
+                provenance_kind=assertion.provenance.kind.value,
+            )
+            for assertion in draft.assertions
+        ),
+        deployment_bindings=tuple(
+            DeploymentBindingSummary(
+                binding_id=binding.binding_id,
+                environment=binding.environment,
+                source_id=binding.source_id,
+                reference_scheme=binding.reference_scheme,
+            )
+            for binding in draft.deployment_bindings
+        ),
+    )
+
+
+class AssemblyLifecycleAdminCapability:
+    """Assembly draft creation, editing, review, approval, and provenance."""
+
+    def __init__(self, dependencies: AdminServiceDependencies, config: AdminServiceConfig) -> None:
+        self._deps = dependencies
+        self._access = AdminDependencyAccess(dependencies)
+        self._config = config
+
+    @_normalize_errors
+    def create_draft(
+        self,
+        draft: AssemblyDraft,
+        *,
+        auth_context: AuthContext,
+    ) -> DraftMutationResult:
+        require_permission(auth_context, Permission.ASSEMBLY_WRITE)
+        require_source(auth_context, draft.source_id)
+        authorization = lifecycle_context(self._deps, auth_context, draft.source_id)
+        require_lifecycle_authorization(
+            context=authorization,
+            authorizer=self._access.lifecycle_authorizer(),
+            required_role=LifecycleRole.AUTHOR,
+            action=LifecycleAction.CREATE_DRAFT,
+            resource_id=draft.draft_id,
+        )
+        if draft.state is not AssemblyState.DRAFT or draft.draft_revision != 0:
+            raise ValidationError("new assembly drafts must start at draft revision 0")
+        if draft.review_submitted_by is not None or draft.approved_by is not None:
+            raise ValidationError("new assembly drafts cannot carry review metadata")
+        if any(
+            assertion.review_state is not ReviewState.PENDING
+            or assertion.review_binding is not None
+            for assertion in draft.assertions
+        ):
+            raise ValidationError("new assembly draft assertions must be pending")
+        draft = AssemblyDraft.model_validate(
+            {
+                **draft.model_dump(mode="python", by_alias=True),
+                "author_reference": authorization.operator_reference,
+            }
+        )
+        try:
+            self._access.draft_store().create(
+                draft,
+                tenant_scope_fingerprint=auth_context.tenant_scope_fingerprint,
+            )
+        except ValueError as error:
+            raise ConflictError("Assembly draft already exists") from error
+        return DraftMutationResult(
+            draft=_draft_to_summary(draft),
+            audit_reference=authorization.operator_reference,
+        )
+
+    @_normalize_errors
+    def get_draft(
+        self,
+        draft_id: str,
+        *,
+        auth_context: AuthContext,
+    ) -> AssemblyDraftDetail:
+        require_permission(auth_context, Permission.ASSEMBLY_READ)
+        return _draft_to_detail(load_draft(self._access, draft_id, auth_context))
+
+    @_normalize_errors
+    def edit_draft(
+        self,
+        draft_id: str,
+        *,
+        expected_revision: int,
+        assertions: tuple[SemanticAssertion, ...] | None = None,
+        deployment_bindings: tuple[DeploymentBinding, ...] | None = None,
+        auth_context: AuthContext,
+    ) -> DraftMutationResult:
+        require_permission(auth_context, Permission.ASSEMBLY_WRITE)
+        current = load_draft(self._access, draft_id, auth_context)
+        authorization = lifecycle_context(self._deps, auth_context, current.source_id)
+        require_lifecycle_authorization(
+            context=authorization,
+            authorizer=self._access.lifecycle_authorizer(),
+            required_role=LifecycleRole.AUTHOR,
+            action=LifecycleAction.EDIT_DRAFT,
+            resource_id=draft_id,
+        )
+        changes: dict[str, object] = {}
+        if assertions is not None:
+            current_by_id = {assertion.id: assertion for assertion in current.assertions}
+            normalized: list[SemanticAssertion] = []
+            for assertion in assertions:
+                authoritative = current_by_id.get(assertion.id)
+                if (
+                    authoritative is not None
+                    and authoritative.type is assertion.type
+                    and authoritative.payload_hash() == assertion.payload_hash()
+                    and authoritative.provenance == assertion.provenance
+                ):
+                    normalized.append(authoritative)
+                    continue
+                normalized.append(
+                    SemanticAssertion.create(
+                        type=assertion.type,
+                        payload=assertion.payload,
+                        provenance=AssertionProvenance(
+                            kind=AssertionProvenanceKind.MANUAL,
+                            source_reference=(
+                                f"seed:{authoritative.id}"
+                                if authoritative is not None
+                                else None
+                            ),
+                        ),
+                    )
+                )
+            changes["assertions"] = tuple(normalized)
+        if deployment_bindings is not None:
+            changes["deployment_bindings"] = deployment_bindings
+        updated = current.mutate(expected_revision=expected_revision, **changes)
+        store_draft(
+            self._access,
+            updated,
+            expected_revision=expected_revision,
+            auth_context=auth_context,
+        )
+        return DraftMutationResult(
+            draft=_draft_to_summary(updated),
+            audit_reference=authorization.operator_reference,
+        )
+
+    @_normalize_errors
+    def submit_draft_for_review(
+        self,
+        draft_id: str,
+        command: DraftRevisionCommand,
+        *,
+        auth_context: AuthContext,
+    ) -> DraftMutationResult:
+        require_permission(auth_context, Permission.ASSEMBLY_WRITE)
+        current = load_draft(self._access, draft_id, auth_context)
+        authorization = lifecycle_context(self._deps, auth_context, current.source_id)
+        outcome = core_submit_for_review(
+            current,
+            expected_revision=command.expected_revision,
+            authorization=authorization,
+            authorizer=self._access.lifecycle_authorizer(),
+        )
+        store_draft(
+            self._access,
+            outcome.draft,
+            expected_revision=command.expected_revision,
+            auth_context=auth_context,
+        )
+        return DraftMutationResult(
+            draft=_draft_to_summary(outcome.draft),
+            audit_reference=authorization.operator_reference,
+        )
+
+    @_normalize_errors
+    def decide_draft_assertion(
+        self,
+        draft_id: str,
+        command: AssertionDecisionCommand,
+        *,
+        auth_context: AuthContext,
+    ) -> DraftMutationResult:
+        require_permission(auth_context, Permission.ASSEMBLY_REVIEW)
+        current = load_draft(self._access, draft_id, auth_context)
+        authorization = lifecycle_context(self._deps, auth_context, current.source_id)
+        if command.action is AssertionDecisionAction.EDIT:
+            if command.semantic_payload is None:
+                raise ValidationError("assertion edit requires semantic_payload")
+            outcome = core_edit_assertion(
+                current,
+                assertion_id=command.assertion_id,
+                payload=command.semantic_payload,
+                expected_revision=command.expected_revision,
+                authorization=authorization,
+                authorizer=self._access.lifecycle_authorizer(),
+                reason=command.reason,
+            )
+        else:
+            decision = (
+                ReviewState.APPROVED
+                if command.action is AssertionDecisionAction.APPROVE
+                else ReviewState.REJECTED
+            )
+            outcome = core_decide_assertion(
+                current,
+                assertion_id=command.assertion_id,
+                decision=decision,
+                expected_revision=command.expected_revision,
+                authorization=authorization,
+                authorizer=self._access.lifecycle_authorizer(),
+                reason=command.reason,
+            )
+        store_draft(
+            self._access,
+            outcome.draft,
+            expected_revision=command.expected_revision,
+            auth_context=auth_context,
+        )
+        return DraftMutationResult(
+            draft=_draft_to_summary(outcome.draft),
+            audit_reference=authorization.operator_reference,
+        )
+
+    @_normalize_errors
+    def approve_assembly_draft(
+        self,
+        draft_id: str,
+        command: DraftRevisionCommand,
+        *,
+        auth_context: AuthContext,
+    ) -> DraftMutationResult:
+        require_permission(auth_context, Permission.ASSEMBLY_APPROVE)
+        current = load_draft(self._access, draft_id, auth_context)
+        authorization = lifecycle_context(self._deps, auth_context, current.source_id)
+        outcome = core_approve_draft(
+            current,
+            expected_revision=command.expected_revision,
+            authorization=authorization,
+            authorizer=self._access.lifecycle_authorizer(),
+        )
+        store_draft(
+            self._access,
+            outcome.draft,
+            expected_revision=command.expected_revision,
+            auth_context=auth_context,
+        )
+        return DraftMutationResult(
+            draft=_draft_to_summary(outcome.draft),
+            audit_reference=authorization.operator_reference,
+        )
+
+    @_normalize_errors
+    def create_draft_from_proposals(
+        self,
+        snapshot_fingerprint: str,
+        *,
+        descriptor_id: str,
+        draft_id: str,
+        bundle_id: str,
+        model_version: str,
+        auth_context: AuthContext,
+    ) -> DraftMutationResult:
+        require_permission(auth_context, Permission.ASSEMBLY_WRITE)
+        catalog = self._access.catalog()
+        proposal_set = catalog.proposal_set(
+            snapshot_fingerprint,
+            tenant_scope_fingerprint=auth_context.tenant_scope_fingerprint,
+        )
+        if proposal_set is None:
+            raise NotFoundError("proposal set")
+        snapshot = catalog.snapshot(
+            snapshot_fingerprint,
+            tenant_scope_fingerprint=auth_context.tenant_scope_fingerprint,
+        )
+        if snapshot is None:
+            raise NotFoundError("snapshot")
+        require_source(auth_context, snapshot.source.source_id)
+        draft = core_create_discovery_draft(
+            proposal_set,
+            descriptor_id=descriptor_id,
+            draft_id=draft_id,
+            bundle_id=bundle_id,
+            source_id=snapshot.source.source_id,
+            model_version=model_version,
+            author_reference=auth_context.audit_reference or self._deps.audit_reference,
+            expected_snapshot_fingerprint=snapshot_fingerprint,
+        )
+        return self.create_draft(draft, auth_context=auth_context)