@tiinex/core 0.1.1

package/src/tooling/portable/draft/draft.create.js

@@ -0,0 +1,389 @@
+import { buildArtifactCreationContract } from '../../../schemas/creation.contracts.js';
+import { portableFinding, summarizePortableFindings } from '../findings.js';
+import { findSchemaMaterial } from '../input/portable.input.js';
+import { buildPortableSchemaGuide, planPortableArtifact } from '../schema/schema.guide.js';
+import { parsePortableSchemaDocument } from '../schema/schema.contract.js';
+import { validatePortableDraft } from './draft.operations.js';
+import { normalizePortableParentRecord, qualifyPortableExactParent, renderPortableLocalContinuityDraft, renderQualifiedPortableExactDraft } from './draft.exact.js';
+import { buildPortableCreationQualification, portableParentRecordHasAnyValue, portableParentRecordIsComplete } from './draft.qualification.js';
+import { creationSchemaReferenceValidationContext } from './draft.validation-context.js';
+export const PORTABLE_DRAFT_CREATION_SCHEMA_ID = 'tiinex.portable.draft-creation.v1';
+export const PORTABLE_STAGED_ARTIFACT_SCHEMA_ID = 'tiinex.portable.staged-artifact.v1';
+export function createPortableLocalDraft(input = {}, options = {}) {
+  const schemaId = String(input.schemaId || options.schemaId || '').trim();
+  const allowIncomplete = input.allowIncomplete === true || options.allowIncomplete === true;
+  const values = normalizeValues(input.values || input.inputs || {});
+  const planResult = planPortableArtifact({ ...input, schemaId, values }, options);
+  const guideResult = buildPortableSchemaGuide({ ...input, schemaId, task: 'create', detail: input.detail || options.detail || 'standard' }, options);
+  const findings = [...(planResult.findings || []), ...(guideResult.findings || [])];
+  const schemaMaterial = findSchemaMaterial(schemaId, input.materials || input);
+  const document = schemaMaterial?.markdown ? parsePortableSchemaDocument(schemaMaterial.markdown) : null;
+  const transitionType = String(input.transitionType || options.transitionType || 'create-artifact').trim() || 'create-artifact';
+  const exactContract = buildArtifactCreationContract({ schemaId, transitionType, schemaReferences: input.schemaReferences || null });
+  const parentRecord = normalizePortableParentRecord(input.parentRecord || input.parent || {});
+  const hasDeclaredParent = portableParentRecordHasAnyValue(parentRecord);
+  const hasCompleteParent = portableParentRecordIsComplete(parentRecord);
+  const exactParentQualification = qualifyPortableExactParent(parentRecord, transitionType);
+  const localContinuityParentCompatible = exactParentQualification.state === 'qualified-local-continuity';
+  const parentRenderable = exactParentQualification.state === 'qualified' || localContinuityParentCompatible;
+  const qualifiedParentRecord = parentRenderable ? exactParentQualification.snapshot : null;
+  const genericParentRecord = transitionType === 'create-artifact' ? parentRecord : qualifiedParentRecord;
+  const exactRendererParentCompatible = exactParentQualification.state === 'qualified';
+  const exactRendererEligible = exactContract.status === 'ready' && exactRendererParentCompatible;
+  const localContinuityRendererEligible = exactContract.status === 'ready' && localContinuityParentCompatible;
+  if (!schemaId) findings.push(portableFinding('error', 'portable.draft-create.schema.required', 'Local draft creation requires a target schema id.'));
+  if (hasDeclaredParent && !hasCompleteParent) findings.push(portableFinding('error', 'portable.draft-create.parent.incomplete', 'A declared Parent must provide explicit Parent Schema authority, Trace (or an explicit parent id), and a recoverable Origin path. A kind label is not Parent Schema authority.', {
+    hasParentSchema: Boolean(parentRecord.schemaId || parentRecord.currentSchemaId),
+    hasTrace: Boolean(parentRecord.continuationTrace || parentRecord.id),
+    hasOrigin: Boolean(parentRecord.path)
+  }));
+  if ((exactContract.status === 'ready' || (hasDeclaredParent && transitionType !== 'create-artifact')) && !parentRenderable) findings.push(portableFinding('error', `portable.draft-create.parent.${exactParentQualification.reason || 'unqualified'}`, 'Creation requires one coherent Parent identity for the requested continuity mode; portable tooling will not rewrite or synthesize Parent authority.', exactParentQualification.evidence || {}));
+  if (localContinuityParentCompatible) {
+    const reason = exactParentQualification.reason || 'continuation-parent-exact-authority-unresolved';
+    const browseConflict = reason === 'continuation-parent-browse-git-root-contract-conflict';
+    findings.push(portableFinding('warning', browseConflict ? 'portable.draft-create.parent.root-browse-git-authority-conflict' : `portable.draft-create.parent.${reason}`, browseConflict
+      ? 'The Parent is a coherent unpublished local artifact. Portable tooling will preserve relative Trace/Origin continuity without inventing browse + git authority, but current Root exact qualification remains unavailable because Parent Origin currently requires browse + git.'
+      : 'The Parent is coherent enough for local relative continuity, but one exact Parent authority dimension remains unresolved. Portable tooling preserves the supplied representation/evidence without upgrading it to exact qualification.', exactParentQualification.evidence || {}));
+  }
+  if (!schemaMaterial && exactContract.status !== 'ready') findings.push(portableFinding('error', 'portable.draft-create.schema-material.required', 'Readable child schema material or exact creation tooling is required; schema meaning will not be guessed.', { schemaId }));
+  if (planResult.plan.missingInputs.length && !allowIncomplete) {
+    findings.push(portableFinding('error', 'portable.draft-create.inputs.blocked', 'Draft creation is blocked until required authoring inputs are supplied or allowIncomplete is explicitly enabled.', {
+      schemaId,
+      missingInputs: planResult.plan.missingInputs
+    }));
+  }
+  if (findings.some((finding) => finding.severity === 'error')) {
+    const summary = summarizePortableFindings(findings);
+    return Object.freeze({
+      schema: PORTABLE_DRAFT_CREATION_SCHEMA_ID,
+      status: 'blocked',
+      schemaId,
+      draft: null,
+      plan: planResult.plan,
+      guide: guideResult.guide,
+      qualification: buildPortableCreationQualification({ schemaId, exactContract, exactRendererApplied: false, exactRendererParentCompatible, exactResultQualification: null, exactParentQualification, hasDeclaredParent, hasCompleteParent, schemaMaterial, validation: null, allowIncomplete, blocked: true }),
+      findings: Object.freeze(findings),
+      findingSummary: summary
+    });
+  }
+  const path = normalizeDraftPath(input.path || `drafts/${slug(input.title || values.Title || values.title || values.Summary || values.summary || schemaLabel(schemaId))}.md`);
+  const title = cleanSingleLine(input.title || values.Title || values.title || values.Summary || values.summary || `${schemaLabel(schemaId)} Draft`, 120);
+  const summary = cleanSingleLine(input.summary || values.Summary || values.summary || title || `${schemaLabel(schemaId)} local draft.`, 360);
+  const createdAt = normalizeArtifactTimestamp(input.createdAt || options.createdAt || new Date());
+  const explicitBodyMarkdown = typeof input.bodyMarkdown === 'string' && input.bodyMarkdown.trim() ? input.bodyMarkdown.trim() : '';
+  const exactRendererInput = {
+    values,
+    createdAt,
+    status: input.currentStatus || 'draft/local',
+    ...(Object.prototype.hasOwnProperty.call(input, 'why') ? { why: input.why } : {}),
+    ...(Object.prototype.hasOwnProperty.call(input, 'authors') ? { authors: input.authors } : {}),
+    childPath: path,
+    ...(Object.prototype.hasOwnProperty.call(input, 'title') ? { title: input.title } : {}),
+    ...(Object.prototype.hasOwnProperty.call(input, 'summary') ? { summary: input.summary } : {}),
+    ...(typeof input.bodyMarkdown === 'string' && input.bodyMarkdown.trim() ? { bodyMarkdown: input.bodyMarkdown } : {})
+  };
+  const exactResult = exactRendererEligible
+    ? renderQualifiedPortableExactDraft({ contract: exactContract, schemaId, transitionType, parentSnapshot: exactParentQualification.snapshot, rendererInput: exactRendererInput })
+    : null;
+  const localContinuityResult = localContinuityRendererEligible
+    ? renderPortableLocalContinuityDraft({ contract: exactContract, schemaId, transitionType, parentSnapshot: exactParentQualification.snapshot, rendererInput: exactRendererInput })
+    : null;
+  const exactRendererApplied = exactResult?.state === 'qualified';
+  const localApplied = localContinuityResult?.state === 'qualified-local-continuity';
+  if (exactRendererEligible && !exactRendererApplied) {
+    findings.push(portableFinding('error', 'portable.draft-create.exact-result.unqualified', 'Exact Site creation tooling did not produce a qualified concrete artifact; portable tooling will not claim exact creation or fall back to rewritten bytes.', { reason: exactResult?.reason || 'unknown' }));
+    const blockedSummary = summarizePortableFindings(findings);
+    return Object.freeze({
+      schema: PORTABLE_DRAFT_CREATION_SCHEMA_ID, status: 'blocked', schemaId, draft: null, plan: planResult.plan, guide: guideResult.guide,
+      qualification: buildPortableCreationQualification({ schemaId, exactContract, exactRendererApplied: false, exactRendererParentCompatible, exactResultQualification: exactResult, exactParentQualification, hasDeclaredParent, hasCompleteParent, schemaMaterial, validation: null, allowIncomplete, blocked: true }),
+      findings: Object.freeze(findings), findingSummary: blockedSummary
+    });
+  }
+  if (localContinuityRendererEligible && !localApplied) {
+    findings.push(portableFinding('error', 'portable.draft-create.local-continuity.unqualified', 'The local Parent could not be rendered with exact relative Trace/Origin continuity. Portable tooling will not fall back to legacy record tokens, scalar Origin, or fabricated publication authority.', { reason: localContinuityResult?.reason || 'unknown' }));
+    const blockedSummary = summarizePortableFindings(findings);
+    return Object.freeze({
+      schema: PORTABLE_DRAFT_CREATION_SCHEMA_ID, status: 'blocked', schemaId, draft: null, plan: planResult.plan, guide: guideResult.guide,
+      qualification: buildPortableCreationQualification({ schemaId, exactContract, exactRendererApplied: false, localContinuityRendererApplied: false, exactRendererParentCompatible, localContinuityParentCompatible, exactResultQualification: localContinuityResult, exactParentQualification, hasDeclaredParent, hasCompleteParent, schemaMaterial, validation: null, allowIncomplete, blocked: true }),
+      findings: Object.freeze(findings), findingSummary: blockedSummary
+    });
+  }
+  const bodyMarkdown = exactRendererApplied
+    ? explicitBodyMarkdown
+    : localApplied
+      ? explicitBodyMarkdown
+    : String(explicitBodyMarkdown || renderBody({
+      title,
+      plan: planResult.plan,
+      document,
+      values,
+      sections: input.sections || {},
+      allowIncomplete
+    })).trim();
+  const markdown = exactRendererApplied
+    ? exactResult.markdown
+    : localApplied
+      ? localContinuityResult.markdown
+    : renderGenericDraft({
+      schemaId,
+      title,
+      summary,
+      createdAt,
+      why: input.why,
+      currentStatus: input.currentStatus,
+      parentRecord: hasCompleteParent && genericParentRecord ? genericParentRecord : {},
+      bodyMarkdown
+    });
+  const draft = Object.freeze({
+    id: String(input.id || path),
+    path,
+    schemaId,
+    markdown,
+    status: 'local',
+    lifecycleStatus: 'draft',
+    sourceMode: 'local-portable-draft',
+    source: null,
+    creationMode: exactRendererApplied ? 'exact-site-creation-contract' : localApplied ? 'local-relative-continuity-authority-conflict' : hasCompleteParent ? 'readable-schema-llm-writer' : 'readable-schema-root-writer',
+    createdAt
+  });
+  const schemaReferenceAuthorities = creationSchemaReferenceValidationContext(exactContract, qualifiedParentRecord || parentRecord);
+  const validation = validatePortableDraft({ ...input, ...draft, schemaReferenceAuthorities, exactCreationValidation: exactResult?.validation || localContinuityResult?.validation || null, files: mergeSchemaFiles(input, schemaMaterial) }, options);
+  findings.push(...(validation.findings || []).filter((finding) => !findings.some((existing) => existing.code === finding.code && existing.message === finding.message)));
+  const status = exactRendererApplied && validation.status === 'clean'
+    ? 'created-clean'
+    : localApplied
+      ? 'created-local-continuity'
+      : validation.status === 'clean'
+        ? 'created-clean'
+        : validation.status === 'degraded'
+          ? 'created-degraded'
+          : allowIncomplete ? 'created-incomplete' : 'created-invalid';
+  const summaryResult = summarizePortableFindings(findings);
+  return Object.freeze({
+    schema: PORTABLE_DRAFT_CREATION_SCHEMA_ID,
+    status,
+    schemaId,
+    draft,
+    plan: planResult.plan,
+    guide: guideResult.guide,
+    validation,
+    qualification: buildPortableCreationQualification({ schemaId, exactContract, exactRendererApplied, localContinuityRendererApplied: localApplied, exactRendererParentCompatible, localContinuityParentCompatible, exactResultQualification: exactResult || localContinuityResult, exactParentQualification, hasDeclaredParent, hasCompleteParent, schemaMaterial, validation, allowIncomplete, blocked: false }),
+    findings: Object.freeze(findings),
+    findingSummary: summaryResult
+  });
+}
+export function stagePortableDraft(input = {}, options = {}) {
+  const draft = normalizeDraftInput(input.draft || input);
+  const allowInvalid = input.allowInvalid === true || options.allowInvalid === true;
+  const validation = input.validation?.schema === 'tiinex.portable.draft-validation.v1'
+    ? input.validation
+    : validatePortableDraft({ ...input, ...draft }, options);
+  const findings = [...(validation.findings || [])];
+  if (!draft.markdown) findings.push(portableFinding('error', 'portable.stage-draft.markdown.required', 'Staging requires a local draft with Markdown content.'));
+  if (!String(draft.sourceMode || '').startsWith('local-')) findings.push(portableFinding('error', 'portable.stage-draft.source-mode.invalid', 'Only local draft material may be staged through portable tooling.', { sourceMode: draft.sourceMode }));
+  if (draft.source) findings.push(portableFinding('error', 'portable.stage-draft.source-object.blocked', 'A portable staged draft must not inherit a source adapter object.'));
+  if (validation.findingSummary?.counts?.error && !allowInvalid) findings.push(portableFinding('error', 'portable.stage-draft.validation.blocked', 'Draft staging is blocked while validation errors remain. Set allowInvalid only for an explicitly incomplete local checkpoint.'));
+  const blocked = findings.some((finding) => finding.severity === 'error');
+  const stagedArtifact = blocked ? null : Object.freeze({
+    schema: PORTABLE_STAGED_ARTIFACT_SCHEMA_ID,
+    id: draft.id || draft.path,
+    path: draft.path,
+    schemaId: draft.schemaId || validation.declaredSchema || validation.requestedSchema,
+    markdown: draft.markdown,
+    state: 'staged-local',
+    lifecycleStatus: validation.findingSummary?.counts?.error ? 'incomplete' : 'draft',
+    sourceMode: 'local-portable-staged',
+    source: null,
+    stagedAt: String(input.stagedAt || options.stagedAt || new Date().toISOString()),
+    qualification: Object.freeze({
+      validationStatus: validation.status,
+      exactRuntimeValidation: Boolean(validation.qualification?.exactRuntimeValidation),
+      contractDrivenStructuralValidation: Boolean(validation.qualification?.contractDrivenStructuralValidation),
+      exportReady: validation.status === 'clean' && Boolean(validation.qualification?.exactRuntimeValidation),
+      limitations: Object.freeze(validation.qualification?.limitations || [])
+    })
+  });
+  const findingSummary = summarizePortableFindings(findings);
+  return Object.freeze({
+    schema: 'tiinex.portable.stage-result.v1',
+    status: blocked ? 'blocked' : 'staged',
+    stagedArtifact,
+    validation,
+    findings: Object.freeze(findings),
+    findingSummary
+  });
+}
+function renderBody({ title, plan, document, values, sections, allowIncomplete }) {
+  const lines = [`# ${title}`];
+  const usedFields = new Set();
+  const sectionMap = normalizeSections(sections);
+  const contractGroups = new Map((document?.validation?.groups || []).map((group) => [normalizeKey(group.name), group]));
+  const requiredSections = (plan.structure || []).map((item) => item.section).filter((section) => !isEnvelopeSection(section));
+  for (const sectionName of requiredSections) {
+    lines.push('', `## ${sectionName}`, '');
+    const explicit = sectionMap.get(normalizeKey(sectionName));
+    if (typeof explicit === 'string') lines.push(explicit.trim());
+    else {
+      const fields = fieldsForGroup(contractGroups.get(normalizeKey(sectionName)));
+      const rendered = [];
+      if (!fields.length) {
+        const sectionValue = valueFor(values, sectionName);
+        if (sectionValue !== undefined) {
+          rendered.push(formatFieldValue(sectionValue));
+          usedFields.add(normalizeKey(sectionName));
+        }
+      }
+      for (const field of fields) {
+        const value = valueFor(values, field);
+        if (value !== undefined) {
+          rendered.push(`- ${field}: ${formatFieldValue(value)}`);
+          usedFields.add(normalizeKey(field));
+        } else if (allowIncomplete) rendered.push(`- ${field}: TODO`);
+      }
+      if (explicit && typeof explicit === 'object') {
+        for (const [field, value] of Object.entries(explicit)) {
+          rendered.push(`- ${field}: ${formatFieldValue(value)}`);
+          usedFields.add(normalizeKey(field));
+        }
+      }
+      lines.push(...(rendered.length ? rendered : [allowIncomplete ? '- TODO: complete this required section.' : '']));
+    }
+  }
+  for (const [sectionName, content] of sectionMap.entries()) {
+    if (requiredSections.some((required) => normalizeKey(required) === sectionName)) continue;
+    lines.push('', `## ${displayKey(sectionName)}`, '');
+    if (typeof content === 'string') lines.push(content.trim());
+    else for (const [field, value] of Object.entries(content || {})) lines.push(`- ${field}: ${formatFieldValue(value)}`);
+  }
+
+  const unassigned = Object.entries(values).filter(([field]) => !['title', 'summary'].includes(normalizeKey(field)) && !usedFields.has(normalizeKey(field)));
+  if (unassigned.length) {
+    lines.push('', '## Additional Declared Inputs', '');
+    for (const [field, value] of unassigned) lines.push(`- ${field}: ${formatFieldValue(value)}`);
+  }
+  return lines.filter((line, index, all) => line !== '' || all[index - 1] !== '').join('\n').trim();
+}
+
+function renderGenericDraft({ schemaId, title, summary, createdAt, why, currentStatus, parentRecord, bodyMarkdown }) {
+  const lines = [
+    '# Continuity Context',
+    '',
+    '- Envelope Schema: [tiinex.root.v1](tiinex.root.v1.schema.md)'
+  ];
+  if (parentRecord.id || parentRecord.path || parentRecord.schemaId) {
+    lines.push(
+      '- Parent',
+      `  - Parent Schema: [${parentRecord.schemaId}](${parentRecord.schemaId}.schema.md)`,
+      ...(parentRecord.createdAt ? [`  - Created At: ${normalizeArtifactTimestamp(parentRecord.createdAt)}`] : []),
+      `  - Trace: ${parentRecord.continuationTrace || `record:${parentRecord.id}`}`,
+      `  - Origin: ${parentRecord.path}`,
+      `  - Boundary: ${parentRecord.boundary || 'portable local material; no source provenance inferred'}`
+    );
+  }
+  lines.push(
+    '- Current',
+    `  - Current Schema: [${schemaId}](${schemaId}.schema.md)`,
+    `  - Created At: ${createdAt}`,
+    `  - Summary: ${summary}`,
+    `  - Status: ${currentStatus || 'draft/local'}`,
+    `  - Why: ${cleanSingleLine(why || 'Created from explicitly supplied readable schema material as a portable local draft.', 360)}`,
+    '',
+    '---',
+    '',
+    bodyMarkdown,
+    '',
+    '# Continuity Integrity',
+    '',
+    '- Draft Local Integrity',
+    '  - Method: portable-readable-schema-draft',
+    '  - Value: pending-validation-and-explicit-export'
+  );
+  return lines.join('\n');
+}
+
+function normalizeArtifactTimestamp(value) {
+  const text = String(value instanceof Date ? value.toISOString() : value || '').trim();
+  if (/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(text)) return text;
+  const date = value instanceof Date ? value : new Date(text);
+  if (Number.isNaN(date.getTime())) return text;
+  return date.toISOString().slice(0, 19).replace('T', ' ');
+}
+
+function mergeSchemaFiles(input, schemaMaterial) {
+  const files = [...(Array.isArray(input.files) ? input.files : [])];
+  if (schemaMaterial && !files.some((file) => file.path === schemaMaterial.path && String(file.content || file.markdown || '') === schemaMaterial.markdown)) {
+    files.push({ path: schemaMaterial.path, content: schemaMaterial.markdown });
+  }
+  return files;
+}
+
+
+function normalizeDraftInput(draft = {}) {
+  return Object.freeze({
+    id: String(draft.id || draft.path || ''),
+    path: normalizeDraftPath(draft.path || 'draft.md'),
+    schemaId: String(draft.schemaId || draft.kind || ''),
+    markdown: String(draft.markdown || ''),
+    sourceMode: String(draft.sourceMode || 'local-portable-draft'),
+    source: draft.source || null
+  });
+}
+
+function normalizeValues(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return {};
+  return Object.fromEntries(Object.entries(value).filter(([, fieldValue]) => fieldValue !== undefined && fieldValue !== null && fieldValue !== ''));
+}
+
+function normalizeSections(value) {
+  const map = new Map();
+  if (!value || typeof value !== 'object') return map;
+  for (const [name, content] of Object.entries(value)) map.set(normalizeKey(name), content);
+  return map;
+}
+
+function fieldsForGroup(group = {}) {
+  const names = new Set(['required fields', 'required entries']);
+  const fields = [];
+  for (const category of group?.categories || []) {
+    if (!names.has(normalizeKey(category.name))) continue;
+    for (const item of category.items || []) fields.push(cleanContractToken(item));
+  }
+  return [...new Set(fields.filter(Boolean))];
+}
+
+function valueFor(values, field) {
+  const wanted = normalizeKey(field);
+  for (const [name, value] of Object.entries(values)) if (normalizeKey(name) === wanted) return value;
+  return undefined;
+}
+
+function cleanContractToken(value = '') {
+  return String(value || '').replace(/`/g, '').replace(/\s+—.*$/, '').replace(/\s+-\s+.*$/, '').replace(/\.$/, '').trim();
+}
+
+function isEnvelopeSection(section = '') {
+  const key = normalizeKey(section);
+  return key === 'continuity context' || key === 'continuity integrity';
+}
+
+function formatFieldValue(value) {
+  if (Array.isArray(value)) return value.join('; ');
+  if (typeof value === 'object') return JSON.stringify(value);
+  return String(value).replace(/\r?\n/g, ' ').trim();
+}
+
+function normalizeDraftPath(value = '') {
+  const path = String(value || '').replace(/\\/g, '/').replace(/^\/+/, '').replace(/\.\.(?:\/|$)/g, '').trim();
+  return path.toLowerCase().endsWith('.md') ? path : `${path || 'draft'}.md`;
+}
+
+function schemaLabel(schemaId = '') {
+  const parts = String(schemaId || 'artifact').split('.').filter(Boolean);
+  const value = parts.length >= 3 ? parts[parts.length - 2] : parts.at(-1) || 'artifact';
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+
+function cleanSingleLine(value, max) { return String(value || '').replace(/\s+/g, ' ').trim().slice(0, max); }
+function slug(value = '') { return String(value || 'artifact').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 80) || 'artifact'; }
+function normalizeKey(value = '') { return String(value || '').toLowerCase().replace(/[`*_#]/g, '').replace(/[^a-z0-9]+/g, ' ').trim(); }
+function displayKey(value = '') { return String(value || '').split(' ').map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(' '); }

package/src/tooling/portable/draft/draft.crud.js

@@ -0,0 +1,175 @@
+import { parseArtifactMarkdown } from '../../../artifacts/artifact.parse.js';
+import { portableFinding, summarizePortableFindings } from '../findings.js';
+import { validatePortableDraft } from './draft.operations.js';
+
+export const PORTABLE_DRAFT_UPDATE_SCHEMA_ID = 'tiinex.portable.draft-update.v1';
+export const PORTABLE_DRAFT_DELETE_SCHEMA_ID = 'tiinex.portable.draft-delete.v1';
+
+export function updatePortableLocalDraft(input = {}, options = {}) {
+  const current = normalizeDraft(input.draft || input.currentDraft || {});
+  const replacementMarkdown = String(input.replacementMarkdown || input.markdown || '').trim();
+  const allowInvalid = input.allowInvalid === true || options.allowInvalid === true;
+  const allowSchemaChange = input.allowSchemaChange === true || options.allowSchemaChange === true;
+  const allowContinuityChange = input.allowContinuityChange === true || options.allowContinuityChange === true;
+  const findings = [];
+
+  validateLocalDraftBoundary(current, findings, 'update');
+  if (!replacementMarkdown) findings.push(portableFinding('error', 'portable.draft-update.replacement.required', 'Updating a local draft requires complete replacement Markdown. Use schema guidance first; partial hidden patch semantics are not inferred.'));
+  if (findings.some((entry) => entry.severity === 'error')) return updateResult('blocked', null, null, findings);
+
+  const before = parseArtifactMarkdown(current.markdown);
+  const after = safeParse(replacementMarkdown, findings);
+  if (!after) return updateResult('blocked', null, null, findings);
+  const beforeIdentity = artifactIdentity(before);
+  const afterIdentity = artifactIdentity(after);
+  if (!afterIdentity.schemaId) findings.push(portableFinding('error', 'portable.draft-update.schema.required', 'Replacement Markdown must declare Current Schema.'));
+  if (!allowSchemaChange && beforeIdentity.schemaId !== afterIdentity.schemaId) findings.push(portableFinding('error', 'portable.draft-update.schema-change.blocked', 'Local draft update cannot silently change Current Schema. Create a new draft or explicitly allow a schema migration.', { before: beforeIdentity.schemaId, after: afterIdentity.schemaId }));
+  if (!allowContinuityChange && !sameContinuity(beforeIdentity, afterIdentity)) findings.push(portableFinding('error', 'portable.draft-update.continuity-change.blocked', 'Local draft update cannot silently change Parent, Trace, or Origin. Create a new lineage child or explicitly allow a continuity repair.', { before: beforeIdentity.parent, after: afterIdentity.parent }));
+
+  const validation = validatePortableDraft({
+    ...input,
+    id: current.id,
+    path: current.path,
+    schemaId: afterIdentity.schemaId || current.schemaId || beforeIdentity.schemaId,
+    markdown: replacementMarkdown,
+    sourceMode: 'local-portable-draft',
+    source: null
+  }, options);
+  findings.push(...(validation.findings || []));
+  const hasErrors = findings.some((entry) => entry.severity === 'error');
+  if (hasErrors && !allowInvalid) return updateResult('blocked', null, validation, findings);
+
+  const updatedAt = String(input.updatedAt || options.updatedAt || new Date().toISOString());
+  const revision = Math.max(0, Number(current.revision || 0)) + 1;
+  const draft = Object.freeze({
+    ...current,
+    schemaId: afterIdentity.schemaId || current.schemaId || beforeIdentity.schemaId,
+    markdown: replacementMarkdown,
+    sourceMode: 'local-portable-draft',
+    source: null,
+    lifecycleStatus: validation.findingSummary?.counts?.error ? 'incomplete' : 'draft',
+    revision,
+    updatedAt
+  });
+  const status = validation.status === 'clean' ? 'updated-clean' : validation.status === 'degraded' ? 'updated-degraded' : 'updated-invalid';
+  return updateResult(status, draft, validation, findings, {
+    previous: Object.freeze({ id: current.id, path: current.path, schemaId: beforeIdentity.schemaId, revision: current.revision || 0 }),
+    qualification: Object.freeze({
+      localOnly: true,
+      sourceMutation: false,
+      remoteWrite: false,
+      schemaChangeAllowed: allowSchemaChange,
+      continuityChangeAllowed: allowContinuityChange,
+      completeReplacementRequired: true
+    })
+  });
+}
+
+export function deletePortableLocalDraft(input = {}, options = {}) {
+  const current = normalizeDraft(input.draft || input.currentDraft || input);
+  const findings = [];
+  validateLocalDraftBoundary(current, findings, 'delete');
+  const expected = String(input.confirmId || input.confirm || options.confirmId || '').trim();
+  const actual = String(current.id || current.path || '').trim();
+  if (!expected) findings.push(portableFinding('error', 'portable.draft-delete.confirmation.required', 'Deleting local draft state requires an explicit confirmation id or path.'));
+  else if (expected !== actual && expected !== current.path) findings.push(portableFinding('error', 'portable.draft-delete.confirmation.mismatch', 'Deletion confirmation does not match the local draft id or path.', { expected, actual, path: current.path }));
+  if (findings.some((entry) => entry.severity === 'error')) return deleteResult('blocked', null, findings);
+
+  const deletion = Object.freeze({
+    schema: PORTABLE_DRAFT_DELETE_SCHEMA_ID,
+    status: 'deleted-local',
+    id: actual,
+    path: current.path,
+    schemaId: current.schemaId || safeParse(current.markdown)?.envelope?.current?.schema?.id || '',
+    reason: String(input.reason || options.reason || 'Explicit local draft removal.').trim(),
+    deletedAt: String(input.deletedAt || options.deletedAt || new Date().toISOString()),
+    retainedContent: false,
+    boundary: Object.freeze({
+      localStateOnly: true,
+      sourceMutation: false,
+      remoteWrite: false,
+      filesystemWritePerformed: false,
+      callerMustApplyRemovalToItsOwnExplicitLocalState: true
+    })
+  });
+  return deleteResult('deleted-local', deletion, findings);
+}
+
+function validateLocalDraftBoundary(draft, findings, action) {
+  if (!draft.markdown) findings.push(portableFinding('error', `portable.draft-${action}.markdown.required`, `${capitalize(action)} requires local draft Markdown.`));
+  if (!String(draft.sourceMode || '').startsWith('local-')) findings.push(portableFinding('error', `portable.draft-${action}.source-mode.invalid`, `${capitalize(action)} is allowed only for explicitly local draft state.`, { sourceMode: draft.sourceMode }));
+  if (draft.source) findings.push(portableFinding('error', `portable.draft-${action}.source-object.blocked`, `${capitalize(action)} must not mutate or inherit a source adapter object.`));
+}
+
+function artifactIdentity(parsed = {}) {
+  const parent = parsed.envelope?.parent || {};
+  return Object.freeze({
+    schemaId: String(parsed.envelope?.current?.schema?.id || ''),
+    parent: Object.freeze({
+      schemaId: String(parent.schema?.id || ''),
+      trace: String(parent.trace || ''),
+      origin: String(parent.origin || '')
+    })
+  });
+}
+
+function sameContinuity(before, after) {
+  return before.parent.schemaId === after.parent.schemaId
+    && before.parent.trace === after.parent.trace
+    && before.parent.origin === after.parent.origin;
+}
+
+function safeParse(markdown, findings = null) {
+  try { return parseArtifactMarkdown(String(markdown || '')); }
+  catch (error) {
+    findings?.push(portableFinding('error', 'portable.draft-update.markdown.invalid', 'Replacement Markdown could not be parsed as a Tiinex artifact.', { detail: String(error?.message || error) }));
+    return null;
+  }
+}
+
+function normalizeDraft(draft = {}) {
+  return Object.freeze({
+    id: String(draft.id || draft.path || ''),
+    path: normalizePath(draft.path || draft.id || 'draft.md'),
+    schemaId: String(draft.schemaId || draft.kind || ''),
+    markdown: String(draft.markdown || ''),
+    status: String(draft.status || 'local'),
+    lifecycleStatus: String(draft.lifecycleStatus || 'draft'),
+    sourceMode: String(draft.sourceMode || 'local-portable-draft'),
+    source: draft.source || null,
+    creationMode: String(draft.creationMode || ''),
+    createdAt: String(draft.createdAt || ''),
+    revision: Math.max(0, Number(draft.revision || 0) || 0)
+  });
+}
+
+function updateResult(status, draft, validation, findings, extra = {}) {
+  const normalized = Object.freeze([...findings]);
+  return Object.freeze({
+    schema: PORTABLE_DRAFT_UPDATE_SCHEMA_ID,
+    status,
+    draft,
+    validation,
+    ...extra,
+    findings: normalized,
+    findingSummary: summarizePortableFindings(normalized)
+  });
+}
+
+function deleteResult(status, deletion, findings) {
+  const normalized = Object.freeze([...findings]);
+  return Object.freeze({
+    schema: PORTABLE_DRAFT_DELETE_SCHEMA_ID,
+    status,
+    deletion,
+    findings: normalized,
+    findingSummary: summarizePortableFindings(normalized)
+  });
+}
+
+function normalizePath(value = '') {
+  const path = String(value || '').replace(/\\/g, '/').replace(/^\/+/, '').replace(/\.\.(?:\/|$)/g, '').trim();
+  return path.toLowerCase().endsWith('.md') ? path : `${path || 'draft'}.md`;
+}
+
+function capitalize(value = '') { return value.charAt(0).toUpperCase() + value.slice(1); }