@tiinex/app 0.1.1

package/src/app/publicTargetRestoreCommand.js

@@ -0,0 +1,149 @@
+import { runGithubSourceOperation } from './githubSourceOperation.js';
+import { runExplicitUrlMaterialImportCommand } from './urlMaterialCommand.js';
+import { openWorkspaceRecordAction, openWorkspaceRecordMemberAction } from './workspaceRecordActions.js';
+import { stateWithWorkspaceViewPatchAndFocus } from './workspaceScopedInteraction.js';
+import {
+  normalizePublicTarget,
+  publicTargetRestoreCapability,
+  PublicTargetRestoreCapability
+} from './publicTarget.js';
+
+export async function runPublicTargetRestoreCommand({
+  target,
+  runtimeApi = {},
+  fetchImpl = globalThis.fetch,
+  workspaceConfig = {},
+  isCurrentOwner = () => true,
+  runGithubOperation = runGithubSourceOperation,
+  runUrlImport = runExplicitUrlMaterialImportCommand
+} = {}) {
+  const normalized = normalizePublicTarget(target);
+  const lifecycle = runtimeApi.lifecycle;
+  if (!normalized) return failure('public-target.invalid', 'Public target is invalid.');
+  const restoreCapability = publicTargetRestoreCapability(normalized);
+  if (restoreCapability === PublicTargetRestoreCapability.invalid) return failure('public-target.invalid', 'Public target is invalid.', { target: normalized });
+  if (restoreCapability === PublicTargetRestoreCapability.unsupported) return failure('public-target.unsupported', 'This public URL target is not a supported Tiinex material target.', { target: normalized });
+  if (!lifecycle?.makeEmptyAppState || !lifecycle?.createWorkspace) return failure('public-target.lifecycle-missing', 'Workspace lifecycle is unavailable.');
+  if (!isCurrentOwner()) return failure('public-target.stale', 'Public target restore was superseded.');
+
+  const created = lifecycle.createWorkspace(lifecycle.makeEmptyAppState(), { id: 'public-target', name: publicTargetLabel(normalized) });
+  if (!created?.ok) return failure(created?.error || 'public-target.workspace-failed', 'Could not create public target workspace.');
+  let state = created.state;
+  const workspaceId = created.workspace.id;
+
+  const materialized = normalized.adapterId === 'github'
+    ? await materializeGithubTarget({ normalized, state, workspaceId, runtimeApi, workspaceConfig, fetchImpl, runGithubOperation, isCurrentOwner })
+    : await runUrlImport({ lifecycle, state, workspaceId, urls: [normalized.externalTarget], fetchImpl });
+  if (!materialized?.ok) return failure(materialized?.error || 'public-target.materialization-failed', materialized?.notice || 'Could not materialize public target.', { target: normalized, state: materialized?.state || state });
+  if (!isCurrentOwner()) return failure('public-target.stale', 'Public target restore was superseded.', { state: materialized.state });
+  state = materialized.state;
+
+  const workspace = workspaceById(state, workspaceId) || lifecycle.activeWorkspace?.(state);
+  const record = selectPublicTargetRecord(workspace, normalized);
+  if (!record) return failure('public-target.record-missing', 'Public target materialized without a matching Tiinex artifact.', { target: normalized, state });
+
+  if (isWorkspaceArtifact(record) && ['workspace', 'workspace.member'].includes(normalized.targetKind)) {
+    const opened = normalized.targetKind === 'workspace.member'
+      ? openWorkspaceRecordMemberAction({ lifecycle, parseWorkspaceConfig: runtimeApi.config?.parseWorkspaceConfig, state, record, memberIdentity: normalized.memberIdentity, descriptorTarget: normalized })
+      : openWorkspaceRecordAction({ lifecycle, parseWorkspaceConfig: runtimeApi.config?.parseWorkspaceConfig, state, record, descriptorTarget: normalized });
+    if (!opened?.ok) return failure(opened?.error || 'public-target.workspace-open-failed', opened?.message || 'Could not open public workspace target.', { target: normalized, state });
+    state = opened.state;
+    if (workspaceId && workspaceById(state, workspaceId) && String(opened.workspace?.id || '') !== workspaceId) {
+      const consumed = lifecycle.closeWorkspace?.(state, workspaceId);
+      if (consumed?.ok) state = consumed.state;
+    }
+    for (const sourceInput of opened.sourceInputs || []) {
+      if (!isCurrentOwner()) return failure('public-target.stale', 'Public target restore was superseded.', { state });
+      const loaded = await materializeWorkspaceSourceInput({ sourceInput, state, runtimeApi, workspaceConfig, fetchImpl, runGithubOperation, isCurrentOwner });
+      if (!loaded?.ok) return failure(loaded?.error || 'public-target.workspace-source-failed', loaded?.message || 'Could not materialize a workspace entrypoint from the public target.', { target: normalized, state: loaded?.state || state });
+      state = loaded.state;
+    }
+    return { ok: true, state, target: normalized, record, workspaceTarget: true, workspace: lifecycle.activeWorkspace?.(state) || null };
+  }
+
+  const selectedState = stateWithWorkspaceViewPatchAndFocus(state, workspace?.id || workspaceId, { workspaceVerse: 'lineage', selectedRecordId: record.id || '' });
+  return { ok: true, state: selectedState, target: normalized, record, workspaceTarget: false, workspace: workspaceById(selectedState, workspace?.id || workspaceId) };
+}
+
+async function materializeGithubTarget({ normalized, state, workspaceId, runtimeApi, workspaceConfig, fetchImpl, runGithubOperation, isCurrentOwner }) {
+  const input = githubInputForTarget(normalized);
+  if (!input) return failure('public-target.github-invalid', 'GitHub public target could not be converted to an exact material request.', { state });
+  const operationRef = { current: { token: null, controller: null } };
+  const out = await runGithubOperation({
+    input: Object.assign({ resetSourceCache: false, allowSourceCache: false }, input),
+    options: { state, workspaceId },
+    state,
+    active: workspaceById(state, workspaceId),
+    runtimeApi,
+    workspaceConfig,
+    operationRef,
+    setNotice: () => {}, setDialog: () => {}, setGithubRequestPending: () => {}, commit: () => {},
+    getLatestState: () => state,
+    fetchImpl,
+    AbortControllerImpl: undefined
+  });
+  if (!isCurrentOwner()) return failure('public-target.stale', 'Public target restore was superseded.', { state: out?.state || state });
+  return out;
+}
+
+async function materializeWorkspaceSourceInput({ sourceInput, state, runtimeApi, workspaceConfig, fetchImpl, runGithubOperation, isCurrentOwner }) {
+  if (String(sourceInput?.adapterId || 'github') !== 'github') return failure('public-target.workspace-source-unsupported', 'Public workspace target requested an unsupported source adapter.', { state });
+  const workspaceId = sourceInput.workspaceId || state.activeWorkspaceId;
+  const operationRef = { current: { token: null, controller: null } };
+  const out = await runGithubOperation({
+    input: Object.assign({ resetSourceCache: false, allowSourceCache: false }, sourceInput),
+    options: { state, workspaceId },
+    state,
+    active: workspaceById(state, workspaceId),
+    runtimeApi,
+    workspaceConfig,
+    operationRef,
+    setNotice: () => {}, setDialog: () => {}, setGithubRequestPending: () => {}, commit: () => {},
+    getLatestState: () => state,
+    fetchImpl,
+    AbortControllerImpl: undefined
+  });
+  if (!isCurrentOwner()) return failure('public-target.stale', 'Public target restore was superseded.', { state: out?.state || state });
+  return out;
+}
+
+function githubInputForTarget(target = {}) {
+  if (target.targetKind === 'github.issue' || target.targetKind === 'github.issue.comment' || target.targetKind === 'github.discussion') {
+    return { repository: target.repository, rootPath: '.topics', repoDiscovery: false, issueDiscovery: false, issueUrls: target.externalTarget, explicitFileRefs: [] };
+  }
+  if (target.targetKind === 'github.file' || target.targetKind === 'workspace' || target.targetKind === 'workspace.member') {
+    if (!target.repository || !target.path) return null;
+    return { repository: target.repository, ref: target.ref || '', rootPath: '.topics', repoDiscovery: false, issueDiscovery: false, issueUrls: '', explicitFileRefs: [target.path] };
+  }
+  return null;
+}
+
+export function selectPublicTargetRecord(workspace = {}, target = {}) {
+  const records = Array.isArray(workspace?.records) ? workspace.records : [];
+  const external = String(target?.externalTarget || '').trim();
+  const commentId = String(target?.commentId || '').trim();
+  const targetPath = String(target?.path || '').replace(/^\/+/, '');
+  const scored = records.map((record) => ({ record, score: scoreRecord(record, { external, commentId, targetPath, target }) })).filter((item) => item.score > 0);
+  scored.sort((a, b) => b.score - a.score || String(a.record.path || '').localeCompare(String(b.record.path || '')));
+  return scored[0]?.record || (records.length === 1 ? records[0] : null);
+}
+
+function scoreRecord(record = {}, context = {}) {
+  const targetKind = String(record?.sourceTarget?.targetKind || '').toLowerCase();
+  const inputTarget = String(record?.sourceTarget?.inputTarget || record?.snapshot?.target?.canonicalUrl || '').trim();
+  const rawUrl = String(record?.sourceTarget?.rawUrl || record?.snapshot?.rawUrl || '').trim();
+  const path = String(record?.sourceTarget?.sourceArtifactPath || record?.path || '').replace(/^\/+/, '');
+  let score = 0;
+  if (context.external && (inputTarget === context.external || rawUrl === context.external)) score += 300;
+  if (context.commentId && (inputTarget.includes(`issuecomment-${context.commentId}`) || rawUrl.includes(`issuecomment-${context.commentId}`))) score += 400;
+  if (context.targetPath && path === context.targetPath) score += 300;
+  if (targetKind.includes('embedded-artifact')) score += 160;
+  if (targetKind.includes('shell') || targetKind.includes('snapshot')) score -= 40;
+  if (isWorkspaceArtifact(record) && ['workspace', 'workspace.member'].includes(context.target?.targetKind)) score += 250;
+  return score;
+}
+
+function isWorkspaceArtifact(record = {}) { return Boolean(record?.workspaceArtifactRole?.openEligible) || /\.workspace\.md$/i.test(String(record?.path || record?.sourceTarget?.sourceArtifactPath || '')); }
+function workspaceById(state = {}, workspaceId = '') { return (Array.isArray(state?.workspaces) ? state.workspaces : []).find((workspace) => workspace.id === workspaceId) || null; }
+function publicTargetLabel(target = {}) { try { const url = new URL(target.externalTarget); return ['workspace', 'workspace.member'].includes(target.targetKind) ? 'Shared workspace' : `Shared ${url.hostname}`; } catch (_) { return 'Shared target'; } }
+function failure(error, message, extra = {}) { return Object.assign({ ok: false, error, message, state: extra.state }, extra); }

package/src/app/recordUi.cache.js

@@ -0,0 +1,35 @@
+import { hydrateGithubRecordFromSourceCache, hydrateGithubWorkspaceFromSourceCache } from '../sources/github/github.transport.js';
+
+const positiveRecordHydration = new WeakMap();
+const workspaceHydration = new WeakMap();
+const NEGATIVE_RECHECK_MS = 1200;
+
+export function cachedHydratedRecord(record, storage) {
+  if (!record || String(record.markdown || '').trim()) return record || null;
+  const cached = positiveRecordHydration.get(record);
+  if (cached) return cached;
+  const hydrated = hydrateGithubRecordFromSourceCache(record, { storage });
+  if (hydrated !== record) positiveRecordHydration.set(record, hydrated);
+  return hydrated;
+}
+
+export function cachedHydratedWorkspace(workspace, storage) {
+  if (!workspace) return null;
+  const records = Array.isArray(workspace.records) ? workspace.records : [];
+  const now = Date.now();
+  const cached = workspaceHydration.get(workspace);
+  if (cached && cached.records === records && (cached.complete || now - cached.checkedAt < NEGATIVE_RECHECK_MS)) return cached.value;
+  const value = hydrateGithubWorkspaceFromSourceCache(workspace, { storage });
+  const hydratedRecords = Array.isArray(value?.records) ? value.records : records;
+  for (let index = 0; index < Math.min(records.length, hydratedRecords.length); index += 1) if (hydratedRecords[index] !== records[index]) positiveRecordHydration.set(records[index], hydratedRecords[index]);
+  const complete = !hydratedRecords.some(recordNeedsSourceCacheHydration);
+  workspaceHydration.set(workspace, { records, value, complete, checkedAt: now });
+  return value;
+}
+
+function recordNeedsSourceCacheHydration(record = {}) {
+  if (String(record.markdown || '').trim()) return false;
+  const source = record.source || {};
+  const adapter = String(source.adapterId || record.sourceMode || '').toLowerCase();
+  return adapter.includes('github') || String(record.sourceMode || '').toLowerCase().includes('source-backed');
+}

package/src/app/recordUi.js

@@ -0,0 +1,11 @@
+import { cachedHydratedRecord, cachedHydratedWorkspace } from './recordUi.cache.js';
+
+function browserStorage() { return typeof window !== 'undefined' ? window.localStorage : null; }
+
+export function hydrateUiRecord(record) {
+  return cachedHydratedRecord(record, browserStorage());
+}
+
+export function hydrateUiWorkspace(workspace) {
+  return cachedHydratedWorkspace(workspace, browserStorage());
+}

package/src/app/routes/RouteSurface.js

@@ -0,0 +1 @@
+export function RouteSurface(route) { return { route }; }

package/src/app/routes/routes.js

@@ -0,0 +1 @@
+export const routes = Object.freeze(['feed','tree','detail','lineage','audit']);

package/src/app/runtimeState.js

@@ -0,0 +1,54 @@
+import { canonicalProductState } from './productStateBoundary.js';
+import { classifyRouteLocation } from './publicTarget.js';
+import { durableLocalAuthorityForRoute } from './historyAuthority.js';
+
+export const CLEAN_URL_BOUNDARY = 'clean-url-does-not-bootstrap-stale-local-storage';
+
+export function runtime() {
+  return {
+    config: window.TiinexWorkspaceConfig,
+    lifecycle: window.TiinexWorkspaceLifecycle,
+    route: window.TiinexWorkspaceRoute,
+    persistence: window.TiinexWorkspacePersistence
+  };
+}
+
+export function defaultState() {
+  return runtime().lifecycle?.makeEmptyAppState?.() || {
+    version: 1,
+    activeWorkspaceId: '',
+    view: { universe: 'column', workspaceVerse: 'feed', reader: 'scan', query: '', displayOptions: { leavesFirst: false, leavesOnly: true, mismatchesOnly: false, showSupportingMarkdown: false, showWorkspaceArtifacts: true, showAssets: false, schemaFilter: 'all', artifactFilter: 'all', sourceFilter: 'all' }, expandedTreeFolders: [] },
+    workspaces: [],
+    audit: null
+  };
+}
+
+export function initialRuntimeSnapshot() {
+  const { lifecycle, route, persistence } = runtime();
+  const routeOwner = classifyRouteLocation(window.location);
+  const durableLocalAuthority = durableLocalAuthorityForRoute(routeOwner.kind, window.history?.state || null);
+  const durableLocalPolicy = durableLocalAuthority === 'isolated-preexisting-recovery' ? 'preserve-existing' : 'normal';
+  const routeResolution = routeOwner.kind === 'semantic-state'
+    ? (persistence?.resolveInitialState?.({ location: window.location, storage: window.localStorage, durableLocalPolicy }) || { requested: true, resolved: false, state: null, reason: 'route-resolution-unavailable' })
+    : { requested: routeOwner.kind === 'public-target', resolved: false, state: null, reason: routeOwner.kind };
+  const routeState = routeResolution?.resolved ? routeResolution.state : null;
+  const resolved = routeState ? route?.normalizeRouteState?.(routeState, lifecycle) || routeState : defaultState();
+  return {
+    state: canonicalProductState(resolved, persistence, 'initial-state'),
+    routeResolved: Boolean(routeResolution?.resolved),
+    routeRequested: Boolean(routeResolution?.requested),
+    routeReason: routeResolution?.reason || '',
+    routeState: routeState || null,
+    routeKind: routeOwner.kind,
+    durableLocalAuthority,
+    publicTarget: routeOwner.target || null
+  };
+}
+
+export function initialState() {
+  return initialRuntimeSnapshot().state;
+}
+
+export function activeWorkspace(state) {
+  return runtime().lifecycle?.activeWorkspace?.(state) || null;
+}

package/src/app/schemaCurrentDeclaration.js

@@ -0,0 +1,69 @@
+import { parseSchemaReferenceValue } from '@tiinex/core/schemas/schema.reference.js';
+
+export const CURRENT_SCHEMA_DECLARATION_AUTHORITY_SCHEMA_ID = 'tiinex.site.current-schema-declaration-authority.v1';
+
+export function qualifyRecordCurrentSchemaDeclaration(record = {}, requestedSchemaId = '') {
+  let markdown;
+  try { markdown = record?.markdown; }
+  catch (exception) {
+    return freezeResult({ state: 'unavailable', materialState: 'read-failed', reason: 'concrete-material-read-failed', requestedSchemaId, exception, occurrences: [] });
+  }
+  if (typeof markdown !== 'string' || !markdown.trim()) {
+    return freezeResult({ state: 'unavailable', materialState: 'unavailable', reason: 'concrete-material-unavailable', requestedSchemaId, occurrences: [] });
+  }
+  return qualifyCurrentSchemaDeclarationMarkdown(markdown, requestedSchemaId);
+}
+
+export function qualifyCurrentSchemaDeclarationMarkdown(markdown = '', requestedSchemaId = '') {
+  const text = String(markdown || '').replace(/\r\n?/g, '\n');
+  if (!text.trim()) return freezeResult({ state: 'unavailable', materialState: 'unavailable', reason: 'concrete-material-unavailable', requestedSchemaId, occurrences: [] });
+  const occurrences = collectCurrentSchemaOccurrences(text);
+  if (occurrences.length === 0) return freezeResult({ state: 'unavailable', materialState: 'concrete', reason: 'current-schema-declaration-missing', requestedSchemaId, occurrences });
+  if (occurrences.length > 1) return freezeResult({ state: 'ambiguous', materialState: 'concrete', reason: 'current-schema-declaration-ambiguous', requestedSchemaId, occurrences });
+
+  const observed = parseSchemaReferenceValue(occurrences[0].raw);
+  const schemaId = observed.schemaId;
+  if (!schemaId) return freezeResult({ state: 'unavailable', materialState: 'concrete', reason: 'current-schema-declaration-invalid', requestedSchemaId, schemaId: '', target: '', observed, occurrences });
+  if (requestedSchemaId && schemaId !== requestedSchemaId) {
+    return freezeResult({ state: 'mismatch', materialState: 'concrete', reason: 'current-schema-declaration-identity-mismatch', requestedSchemaId, schemaId, target: observed.target || '', observed, occurrences });
+  }
+  return freezeResult({ state: 'qualified', materialState: 'concrete', reason: '', requestedSchemaId, schemaId, target: observed.target || '', observed, occurrences });
+}
+
+function collectCurrentSchemaOccurrences(markdown = '') {
+  const envelope = String(markdown || '').split(/^---\s*$/m, 1)[0] || '';
+  const lines = envelope.split('\n');
+  const occurrences = [];
+  let inCurrent = false;
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (/^-\s+Current\s*$/u.test(line)) {
+      inCurrent = true;
+      continue;
+    }
+    if (/^-\s+\S/u.test(line)) {
+      inCurrent = false;
+      continue;
+    }
+    if (!inCurrent) continue;
+    const match = line.match(/^\s+-\s*Current Schema:\s*(.*?)\s*$/u);
+    if (!match) continue;
+    occurrences.push(Object.freeze({ line: index + 1, raw: match[1] }));
+  }
+  return occurrences;
+}
+
+function freezeResult(value = {}) {
+  const occurrences = Object.freeze([...(value.occurrences || [])]);
+  return Object.freeze(Object.assign({
+    schema: CURRENT_SCHEMA_DECLARATION_AUTHORITY_SCHEMA_ID,
+    state: 'unavailable',
+    materialState: 'unavailable',
+    reason: '',
+    requestedSchemaId: '',
+    schemaId: '',
+    target: '',
+    observed: null,
+    occurrences
+  }, value, { occurrences }));
+}

package/src/app/schemaFactoryLocalCreateCommand.js

@@ -0,0 +1,101 @@
+import { createRecordFromMarkdown } from '@tiinex/core/artifacts/artifact.record.js';
+import { buildArtifactCreationContract, createArtifactDraftMarkdown, validateArtifactCreationResult } from '@tiinex/core/schemas/creation.contracts.js';
+import { firstMissingSchemaFactoryAuthoringInput, isSchemaFactoryViewerCreateAction, normalizeSchemaFactoryAuthoringValues, projectSchemaFactoryViewerCreateAction } from '../schemas/schema.factory.viewerProjection.js';
+import { allocateRootArtifactPath } from '@tiinex/core/transitions/record.transitions.js';
+import { durableLocalMutationDecision, DurableLocalMutationOperation } from './durableLocalMutationPolicy.js';
+import { explicitPlacementPath } from './workspacePlacementOptions.js';
+
+export const SCHEMA_FACTORY_LOCAL_CREATE_COMMAND_SCHEMA_ID = 'tiinex.site.schema-factory-local-create-command.v1';
+
+export function executeSchemaFactoryLocalCreate(input = {}) {
+  const state = input.state || {};
+  const workspace = (state.workspaces || []).find((item) => String(item?.id || '') === String(input.workspaceId || ''));
+  if (!workspace) return refusal('workspace-not-found', state, 'Artifact cannot be created because the target workspace is unavailable.');
+  if (input.currentRecordId) return refusal('schema-factory-root-create-source-unexpected', state, 'Standalone factory creation cannot bind a selected source artifact.');
+
+  const suppliedAction = input.action || {};
+  if (!isSchemaFactoryViewerCreateAction(suppliedAction)) return refusal('schema-factory-action-required', state, 'Artifact cannot be created because the selected action is not a shared schema-factory create projection.');
+  const schemaId = String(suppliedAction?.authoring?.schemaId || '').trim();
+  const action = projectSchemaFactoryViewerCreateAction(schemaId);
+  if (!action.productCapable || action.definitionKey !== suppliedAction.definitionKey) return refusal('schema-factory-action-unqualified', state, `${action.authoring?.schemaLabel || 'Artifact'} cannot be created because its shared factory projection is not qualified.`);
+
+  const values = normalizeSchemaFactoryAuthoringValues(action, input.values || {});
+  const missing = firstMissingSchemaFactoryAuthoringInput(action, values);
+  if (missing) return refusal('schema-factory-input-incomplete', state, `Complete ${missing} before creating the local ${String(action.authoring?.schemaLabel || 'artifact').toLowerCase()}.`);
+
+  const contract = buildArtifactCreationContract({ schemaId, transitionType: 'create-artifact' });
+  if (contract.status !== 'ready' || contract.id !== action.authoring.creationContractId) return refusal('schema-factory-contract-unqualified', state, `${action.authoring?.schemaLabel || 'Artifact'} cannot be created because its exact Artifact Creation Contract is not ready.`);
+
+  const titleBinding = (contract.creation?.inputBindings || []).find((binding) => binding?.kind === 'root-current-summary-body-title');
+  const outputTitle = String(titleBinding ? values?.[titleBinding.input] : `${contract.target?.label || 'Artifact'} Draft`).trim() || `${contract.target?.label || 'Artifact'} Draft`;
+  const automaticAllocation = allocateRootArtifactPath({ targetId: schemaId, targetLabel: contract.target?.label || schemaId, title: outputTitle }, { workspaceRecords: workspace.records || [] });
+  const placementFolder = String(input.placementFolder || '').trim();
+  const requestedPath = placementFolder ? explicitPlacementPath(automaticAllocation.path, placementFolder) : '';
+  const allocation = requestedPath
+    ? allocateRootArtifactPath({ targetId: schemaId, targetLabel: contract.target?.label || schemaId, title: outputTitle }, { workspaceRecords: workspace.records || [], path: requestedPath })
+    : automaticAllocation;
+  const concretePath = allocation.path || '';
+  if (!concretePath) return refusal('schema-factory-path-allocation-unavailable', state, `${contract.target?.label || 'Artifact'} cannot be created because its browser-local path could not be allocated.`);
+
+  const createdAt = input.createdAt !== undefined ? input.createdAt : (typeof input.clock === 'function' ? input.clock() : new Date());
+  let markdown = '';
+  try {
+    markdown = createArtifactDraftMarkdown(contract, { values, childPath: concretePath, createdAt });
+  } catch (error) {
+    return refusal('schema-factory-render-failed', state, `${contract.target?.label || 'Artifact'} could not be rendered from its qualified creation contract.`, { exception: String(error?.message || error || '') });
+  }
+  if (!markdown) return refusal('schema-factory-render-unqualified', state, `${contract.target?.label || 'Artifact'} could not be rendered and validated from its qualified creation contract.`);
+
+  const artifactValidation = validateArtifactCreationResult({ schemaId, status: 'local', sourceMode: 'local-schema-factory-create', path: concretePath, markdown }, {}, { contract, childPath: concretePath });
+  if (!artifactValidation.ok) return refusal('schema-factory-validation-failed', state, `${contract.target?.label || 'Artifact'} was not committed because shared schema validation did not qualify the rendered result.`, { artifactValidation });
+
+  const authority = durableLocalMutationDecision(input.persistenceOwnership, DurableLocalMutationOperation.localDraftCreate);
+  if (!authority.ok) return refusal(authority.error || 'local-mutation-not-authorized', state, authority.notice || `Local ${contract.target?.label || 'artifact'} creation is not available in this session.`, { authority, artifactValidation });
+  if (!input.lifecycle?.addWorkspaceRecord) return refusal('workspace-lifecycle-unavailable', state, `${contract.target?.label || 'Artifact'} cannot be created because the local workspace lifecycle is unavailable.`, { artifactValidation });
+
+  const parsedRecord = createRecordFromMarkdown(markdown, { path: concretePath, sourceMode: 'local-schema-factory-create' });
+  const candidate = Object.freeze({
+    ...parsedRecord,
+    sourceMode: 'local-schema-factory-create',
+    path: concretePath,
+    factoryMaterialization: Object.freeze({
+      schema: SCHEMA_FACTORY_LOCAL_CREATE_COMMAND_SCHEMA_ID,
+      descriptorSchema: action.authoring.factoryDescriptorSchema,
+      creationContractId: contract.id,
+      schemaId,
+      transitionAuthority: 'not-invoked',
+      remoteWrite: false,
+      sourceMutation: false,
+      placement: Object.freeze({ mode: placementFolder ? 'explicit-same-workspace-folder' : 'automatic', folder: placementFolder, path: concretePath })
+    })
+  });
+  const committed = input.lifecycle.addWorkspaceRecord(state, workspace.id, candidate, { clock: input.clock });
+  if (!committed?.ok) return refusal(committed?.error || 'workspace-mutation-failed', state, `${contract.target?.label || 'Artifact'} could not be added to the browser-local workspace.`, { artifactValidation });
+
+  const createdSource = committed.record?.source || {};
+  if (createdSource.adapterId === 'github' || createdSource.repository || createdSource.repo || createdSource.ref || committed.record?.sourceTarget) {
+    return refusal('post-mutation-source-boundary-violation', state, `${contract.target?.label || 'Artifact'} creation was refused because the browser-local artifact inherited source provenance.`, { artifactValidation });
+  }
+
+  return Object.freeze({
+    ok: true,
+    schema: SCHEMA_FACTORY_LOCAL_CREATE_COMMAND_SCHEMA_ID,
+    state: committed.state,
+    workspace: committed.workspace,
+    record: committed.record,
+    artifactValidation,
+    factoryDescriptor: action.authoring.builderDescriptor,
+    creationContract: contract,
+    remoteWrite: false,
+    sourceMutation: false,
+    transitionAuthority: 'not-invoked',
+    concretePath,
+    continuityMode: 'root',
+    placement: Object.freeze({ mode: placementFolder ? 'explicit-same-workspace-folder' : 'automatic', folder: placementFolder, path: concretePath }),
+    notice: `Created and schema-validated standalone local ${contract.target?.label || 'artifact'} in ${workspace.name || workspace.title || 'workspace'}.`
+  });
+}
+
+function refusal(error, state, notice, extra = {}) {
+  return Object.freeze({ ok: false, schema: SCHEMA_FACTORY_LOCAL_CREATE_COMMAND_SCHEMA_ID, error, state, notice, ...extra, remoteWrite: false, sourceMutation: false, transitionAuthority: 'not-invoked', concretePath: null });
+}

package/src/app/schemaFactoryViewerProof.case.mjs

@@ -0,0 +1,134 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import { schemaFactoryViewerProofActions, schemaFactoryViewerProofCapabilities, SCHEMA_FACTORY_VIEWER_PROOF_SCHEMA_IDS } from './schemaFactoryViewerProof.js';
+import { buildArtifactCreationContract, renderArtifactCreationCandidateMarkdown, validateArtifactCreationResult } from '@tiinex/core/schemas/creation.contracts.js';
+import { GENERIC_ARTIFACT_CREATION_RENDERER_ID } from '@tiinex/core/schemas/creation.renderer.js';
+import { resolveSchemaCapabilities } from '@tiinex/core/schemas/capability.registry.js';
+
+const projections = schemaFactoryViewerProofCapabilities();
+assert.equal(projections.length, 6);
+assert.deepEqual(projections.map((item) => item.authoring.schemaId), SCHEMA_FACTORY_VIEWER_PROOF_SCHEMA_IDS);
+assert.equal(schemaFactoryViewerProofActions().length, 0, 'No factory projection may become an invocable Create action without separately qualified Transition Definition applicability.');
+
+for (const projection of projections) {
+  const descriptor = resolveSchemaCapabilities({ schemaId: projection.authoring.schemaId }).descriptor;
+  assert.equal(descriptor.actions.read.status, 'implemented', `${projection.authoring.schemaId} must remain readable`);
+  assert.equal(descriptor.actions.validate.status, 'implemented', `${projection.authoring.schemaId} must remain validatable`);
+  assert.equal(projection.transitionAuthority.authority, 'canonical-transition-definition');
+  assert.equal(projection.capability.invocableCreate, 'unavailable');
+  assert.equal(projection.productCapable, false);
+}
+
+const byId = Object.fromEntries(projections.map((item) => [item.authoring.schemaId, item]));
+for (const schemaId of ['tiinex.decision.v1', 'tiinex.evidence.v1', 'tiinex.handoff.v1', 'tiinex.validation.finding.v1', 'tiinex.validation.report.v1']) {
+  const projection = byId[schemaId];
+  assert.equal(projection.capability.generationReady, true, `${schemaId} must retain qualified shared generation`);
+  assert.equal(projection.capability.state, 'generation-qualified-transition-unavailable');
+  assert.equal(resolveSchemaCapabilities({ schemaId }).descriptor.factory.generation.ready, true);
+  assert.equal(resolveSchemaCapabilities({ schemaId }).descriptor.factory.capabilities.generation.implementation.renderer.id, GENERIC_ARTIFACT_CREATION_RENDERER_ID);
+}
+
+const method = byId['tiinex.validation.method.v1'];
+assert.equal(method.capability.generationReady, false);
+assert.equal(method.capability.generationAuthority, 'unavailable');
+assert.equal(method.authoring.requiredInputs.length, 0);
+assert.equal(buildArtifactCreationContract({ schemaId: 'tiinex.validation.method.v1' }).status, 'blocked');
+
+const report = byId['tiinex.validation.report.v1'];
+assert.equal(report.authoring.requiredInputs.length, 11);
+assert.ok(report.authoring.inputDescriptors.every((item) => item.kind === 'ordinary-field'));
+const reportSummary = report.authoring.inputDescriptors.find((item) => item.name === 'Summary');
+assert.deepEqual({ section: reportSummary.section, group: reportSummary.group, field: reportSummary.field }, { section: 'Findings Summary', group: 'Findings Summary', field: 'Summary' });
+
+const samples = {
+  'tiinex.decision.v1': {
+    Summary: 'Viewer factory decision proof',
+    Decision: 'Use the shared schema factory rendering path.',
+    Basis: 'The Artifact Creation Contract and factory descriptor are qualified.',
+    Consequences: 'Generation remains separate from transition invocation.'
+  },
+  'tiinex.evidence.v1': {
+    'Supported Claim Or Question': 'whether Viewer generation consumes the shared factory',
+    'Evidence Role': 'supports the bounded product proof',
+    'Known Source': 'browser-local proof fixture',
+    'Preservation Basis': 'rendered through the qualified Artifact Creation Contract',
+    'Provenance Limits': 'local product proof only',
+    Material: 'factory-generated Viewer artifact',
+    'Material Kind': 'local proof record',
+    'Preservation State': 'preserved in local proof output',
+    'Fidelity Notes': 'required structured values are retained exactly',
+    'Known Losses': 'remote publication state not tested',
+    'Does Not Prove': 'invocable transition authority',
+    'Must Not Be Treated As': 'remote canonical publication proof'
+  },
+  'tiinex.handoff.v1': {
+    Purpose: 'Return bounded Viewer factory proof.',
+    From: 'Kodax',
+    'From Kind': 'role',
+    To: 'Anchor',
+    'To Kind': 'role',
+    Transfers: [{ name: 'viewer-proof', fields: { 'Transfer Kind': 'work-and-responsibility', Description: 'Exercise shared generation and validation.', Boundary: 'No synthetic transition.' } }],
+    'Required Context': 'none',
+    'Reference Context': 'none',
+    'Retained Responsibilities': [{ name: 'acceptance', fields: { 'Retained By': 'Sigma', Responsibility: 'Accept or reject the factory pattern.' } }],
+    'Exclusions And Dependencies': [{ name: 'remote-publication', fields: { Kind: 'excluded-scope', Description: 'No remote Docs publication in this proof.' } }],
+    'Completion Expectation': { 'Signal Kind': 'return', 'Signal Meaning': 'Return qualified local factory evidence.', 'Return To': 'Anchor' },
+    'Interpretation Limits': { 'Does Not Mean': 'This does not authorize broad schema fan-out.', 'Must Not Be Used To Claim': 'This does not prove transition applicability.', 'Authority Limits': 'Schema semantics remain factory/canonical-material owned.' }
+  },
+  'tiinex.validation.finding.v1': {
+    Target: 'Viewer schema factory proof',
+    'Target Kind': 'browser-local product path',
+    Method: 'shared contract-driven generation and validation',
+    'Method Scope': 'Decision Evidence Handoff Validation Finding',
+    Status: 'pass',
+    Observation: 'shared factory output validated without transition invocation',
+    'What Was Checked': 'factory descriptor generation read projection and validation',
+    'What Was Not Checked': 'remote publication or transition applicability',
+    'Recommended Response': 'retain the shared generic path',
+    'Does Not Prove': 'catalog-wide schema readiness',
+    'Must Not Be Treated As': 'semantic acceptance'
+  },
+  'tiinex.validation.report.v1': {
+    Scope: 'bounded Viewer factory scale proof',
+    Targets: 'Validation Method and Validation Report',
+    'Methods Used': 'shared descriptor renderer and validator',
+    'Method Boundaries': 'local proof only',
+    Summary: 'Generation is qualified while invocable Create remains unavailable.',
+    'Overall State': 'generation-qualified-transition-unavailable',
+    Findings: 'all eleven required inputs use ordinary-field bindings',
+    'Run Context': 'bounded Viewer proof',
+    'What Was Not Checked': 'future canonical Transition Definition applicability',
+    'Does Not Prove': 'an invocable Create action exists',
+    'Must Not Hide': 'generation and invocation are independent capability dimensions'
+  }
+};
+
+const generated = [];
+for (const schemaId of Object.keys(samples)) {
+  const contract = buildArtifactCreationContract({ schemaId });
+  assert.equal(contract.status, 'ready', `${schemaId} generation contract must remain ready`);
+  assert.equal(contract.capabilities.create, 'implemented');
+  const markdown = renderArtifactCreationCandidateMarkdown(contract, { values: samples[schemaId], createdAt: '2026-09-04T13:00:00.000Z' });
+  assert.ok(markdown, `${schemaId} must render through the shared generic generation path`);
+  const validation = validateArtifactCreationResult({ schemaId, status: 'local', sourceMode: 'local-factory-proof', path: `${schemaId}.viewer-proof.trace.md`, markdown }, {}, { contract, childPath: `${schemaId}.viewer-proof.trace.md` });
+  assert.equal(validation.counts.errors, 0, `${schemaId}: ${JSON.stringify(validation.findings, null, 2)}`);
+  generated.push({ schemaId, status: validation.status });
+}
+
+const reportMarkdown = renderArtifactCreationCandidateMarkdown(buildArtifactCreationContract({ schemaId: 'tiinex.validation.report.v1' }), { values: samples['tiinex.validation.report.v1'], createdAt: '2026-09-04T13:00:00.000Z' });
+assert.ok(reportMarkdown.includes('## Findings Summary\n\n- Summary: Generation is qualified while invocable Create remains unavailable.'));
+
+const appSource = fs.readFileSync(new URL('./TiinexApp.jsx', import.meta.url), 'utf8');
+assert.ok(appSource.includes('schemaFactoryViewerProofActions()'), 'Workspace Create continues to consume only product-capable factory actions; unqualified generation descriptors are filtered before UI invocation.');
+
+console.log(JSON.stringify({
+  schema: 'tiinex.site.schema-factory-viewer-proof.v2',
+  schemas: SCHEMA_FACTORY_VIEWER_PROOF_SCHEMA_IDS,
+  generated,
+  generationQualified: projections.filter((item) => item.capability.generationReady).map((item) => item.authoring.schemaId),
+  generationUnavailable: projections.filter((item) => !item.capability.generationReady).map((item) => item.authoring.schemaId),
+  invocableCreateActions: schemaFactoryViewerProofActions().length,
+  validationErrors: 0,
+  renderer: GENERIC_ARTIFACT_CREATION_RENDERER_ID,
+  boundary: 'Viewer/Builder capability proof: read/validate, generation authority, and invocable Transition authority remain independent.'
+}, null, 2));

package/src/app/schemaFactoryViewerProof.js

@@ -0,0 +1,20 @@
+import { projectSchemaFactoryViewerCreateAction, projectSchemaFactoryViewerCreateActions } from '../schemas/schema.factory.viewerProjection.js';
+
+export const SCHEMA_FACTORY_VIEWER_PROOF_SCHEMA_IDS = Object.freeze([
+  'tiinex.decision.v1',
+  'tiinex.evidence.v1',
+  'tiinex.handoff.v1',
+  'tiinex.validation.finding.v1',
+  'tiinex.validation.method.v1',
+  'tiinex.validation.report.v1'
+]);
+
+export function schemaFactoryViewerProofCapabilities() {
+  return Object.freeze(SCHEMA_FACTORY_VIEWER_PROOF_SCHEMA_IDS.map(projectSchemaFactoryViewerCreateAction));
+}
+
+export function schemaFactoryViewerProofActions() {
+  return projectSchemaFactoryViewerCreateActions(SCHEMA_FACTORY_VIEWER_PROOF_SCHEMA_IDS);
+}
+
+export const SCHEMA_FACTORY_VIEWER_PROOF_BOUNDARY = 'Task-bounded Viewer qualification set only. Membership is product-proof scope, not schema semantics, transition applicability, companion policy, or catalog-wide creatability authority. Generation descriptors remain visible even when no invocable Create transition is qualified.';