@fundamental-engine/core 0.9.4 → 0.10.0

package/dist/world/opportunity/opportunity.d.ts

@@ -0,0 +1,85 @@
+/**
+ * F1.6 — system-relative opportunity `Ω_sys` (RUNTIME-DERIVED only). Evaluates one (participant,
+ * operation, state, projection, history) context and returns per-predicate results with evidence.
+ *
+ * It NEVER includes belief, perceived availability, interpretation, expectation, confidence, experience,
+ * or human strategy — those are empirically inferred (M1.5-01) and out of scope. Capability and authority
+ * stay separate: `Capable(...)` = can execution occur; `Permitted(...)` = may it occur under governance,
+ * and every permission requires an `authoritySource`. Field-free; internal; not exported.
+ */
+import type { WorldVersionEnvelope } from '../envelope.ts';
+export interface OperationDecl {
+    readonly id: string;
+    readonly reversible: boolean;
+    /** operation ids that recover from this one (empty ⇒ no recovery path). */
+    readonly recoveryPaths: readonly string[];
+}
+export interface AuthorityGrant {
+    readonly operation: string;
+    readonly scope: string;
+    /** REQUIRED provenance of the permission. Empty or 'unknown' ⇒ not a valid grant. */
+    readonly authoritySource: string;
+}
+export interface OpportunityProjection {
+    readonly id: string;
+    readonly exposed: readonly string[];
+    readonly signaled: readonly string[];
+}
+export interface OpportunityState {
+    readonly enabled: readonly string[];
+    readonly reachableOutcomes: readonly string[];
+}
+export interface OpportunityWorld {
+    readonly envelope: WorldVersionEnvelope;
+    readonly operations: readonly OperationDecl[];
+}
+export interface OpportunityContext {
+    readonly world: OpportunityWorld;
+    readonly participant: string;
+    readonly state: OpportunityState;
+    readonly projection: OpportunityProjection;
+    readonly history: readonly string[];
+    /** operations this participant can effectively execute (capability, NOT permission). */
+    readonly capabilities: readonly string[];
+    readonly authority: readonly AuthorityGrant[];
+}
+export type PredicateName = 'domain-valid' | 'capable' | 'permitted' | 'enabled' | 'reachable' | 'exposed' | 'signaled' | 'reversible-or-recoverable';
+export type PredicateFailureReason = 'unsupported-operation' | 'not-capable' | 'no-authority' | 'unknown-authority-source' | 'preconditions-unmet' | 'unreachable' | 'not-exposed' | 'not-signaled' | 'irreversible-no-recovery';
+export interface PredicateFailure {
+    readonly predicate: PredicateName;
+    readonly reason: PredicateFailureReason;
+}
+export interface PredicateEvidence {
+    readonly predicate: PredicateName;
+    readonly value: boolean;
+    readonly basis: string;
+    readonly authoritySource?: string;
+}
+export interface OpportunityEvidence {
+    /** Retains the world/version envelope so the result can be reconstructed. */
+    readonly envelope: WorldVersionEnvelope;
+    readonly participant: string;
+    readonly operation: string;
+    readonly projection: string;
+    readonly historyLength: number;
+    readonly predicates: readonly PredicateEvidence[];
+}
+export interface OpportunityResult {
+    readonly operation: string;
+    readonly participant: string;
+    readonly domainValid: boolean;
+    readonly capable: boolean;
+    readonly permitted: boolean;
+    readonly enabled: boolean;
+    readonly reachable: boolean;
+    readonly exposed: boolean;
+    readonly signaled: boolean;
+    readonly reversible: boolean;
+    readonly recoveryPaths: readonly string[];
+    /** The system-relative availability conjunction — ALWAYS accompanied by predicate-level evidence. */
+    readonly available: boolean;
+    readonly failedPredicates: readonly PredicateFailure[];
+    readonly evidence: OpportunityEvidence;
+}
+export declare function evaluateOpportunity(context: OpportunityContext, operation: string): OpportunityResult;
+//# sourceMappingURL=opportunity.d.ts.map

package/dist/world/opportunity/opportunity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opportunity.d.ts","sourceRoot":"","sources":["../../../src/world/opportunity/opportunity.ts"],"names":[],"mappings":"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"}

package/dist/world/opportunity/opportunity.js

@@ -0,0 +1,67 @@
+function validGrant(g) {
+    return g.authoritySource.length > 0 && g.authoritySource !== 'unknown';
+}
+export function evaluateOpportunity(context, operation) {
+    const decl = context.world.operations.find((o) => o.id === operation);
+    const domainValid = decl !== undefined;
+    const capable = context.capabilities.includes(operation);
+    const grants = context.authority.filter((g) => g.operation === operation);
+    const validGrants = grants.filter(validGrant);
+    const permitted = validGrants.length > 0;
+    const hasUnknownSourceGrant = grants.length > 0 && validGrants.length === 0;
+    const enabled = context.state.enabled.includes(operation);
+    const reachable = context.state.reachableOutcomes.includes(operation);
+    const exposed = context.projection.exposed.includes(operation);
+    const signaled = context.projection.signaled.includes(operation);
+    const reversible = decl?.reversible ?? false;
+    const recoveryPaths = decl?.recoveryPaths ?? [];
+    const reversibleOrRecoverable = reversible || recoveryPaths.length > 0;
+    const failedPredicates = [];
+    if (!domainValid)
+        failedPredicates.push({ predicate: 'domain-valid', reason: 'unsupported-operation' });
+    if (!capable)
+        failedPredicates.push({ predicate: 'capable', reason: 'not-capable' });
+    if (!permitted)
+        failedPredicates.push({ predicate: 'permitted', reason: hasUnknownSourceGrant ? 'unknown-authority-source' : 'no-authority' });
+    if (!enabled)
+        failedPredicates.push({ predicate: 'enabled', reason: 'preconditions-unmet' });
+    if (!reachable)
+        failedPredicates.push({ predicate: 'reachable', reason: 'unreachable' });
+    if (!exposed)
+        failedPredicates.push({ predicate: 'exposed', reason: 'not-exposed' });
+    if (!signaled)
+        failedPredicates.push({ predicate: 'signaled', reason: 'not-signaled' });
+    if (!reversibleOrRecoverable)
+        failedPredicates.push({ predicate: 'reversible-or-recoverable', reason: 'irreversible-no-recovery' });
+    const authoritySource = validGrants[0]?.authoritySource ?? (hasUnknownSourceGrant ? grants[0]?.authoritySource : undefined);
+    const predicates = [
+        { predicate: 'domain-valid', value: domainValid, basis: `operation ${domainValid ? 'in' : 'not in'} world vocabulary` },
+        { predicate: 'capable', value: capable, basis: `participant ${context.participant} capabilities` },
+        { predicate: 'permitted', value: permitted, basis: `${validGrants.length} valid grant(s) of ${grants.length}`, authoritySource },
+        { predicate: 'enabled', value: enabled, basis: `preconditions under state (history len ${context.history.length})` },
+        { predicate: 'reachable', value: reachable, basis: 'reachable outcomes' },
+        { predicate: 'exposed', value: exposed, basis: `projection ${context.projection.id}` },
+        { predicate: 'signaled', value: signaled, basis: `projection ${context.projection.id}` },
+        { predicate: 'reversible-or-recoverable', value: reversibleOrRecoverable, basis: `reversible=${reversible}, recovery=${recoveryPaths.length}` },
+    ];
+    // system-relative availability: can be invoked to effect NOW. (signaled = discoverability, reported
+    // separately; reversibility = a safety property, reported separately.)
+    const available = domainValid && capable && permitted && enabled && reachable && exposed;
+    return {
+        operation,
+        participant: context.participant,
+        domainValid, capable, permitted, enabled, reachable, exposed, signaled, reversible,
+        recoveryPaths,
+        available,
+        failedPredicates,
+        evidence: {
+            envelope: context.world.envelope,
+            participant: context.participant,
+            operation,
+            projection: context.projection.id,
+            historyLength: context.history.length,
+            predicates,
+        },
+    };
+}
+//# sourceMappingURL=opportunity.js.map

package/dist/world/opportunity/opportunity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"opportunity.js","sourceRoot":"","sources":["../../../src/world/opportunity/opportunity.ts"],"names":[],"mappings":"AAiHA,SAAS,UAAU,CAAC,CAAiB;IACnC,OAAO,CAAC,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,CAAC,eAAe,KAAK,SAAS,CAAC;AACzE,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,OAA2B,EAAE,SAAiB;IAChF,MAAM,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,SAAS,CAAC,CAAC;IACtE,MAAM,WAAW,GAAG,IAAI,KAAK,SAAS,CAAC;IAEvC,MAAM,OAAO,GAAG,OAAO,CAAC,YAAY,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;IAEzD,MAAM,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC;IAC1E,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;IAC9C,MAAM,SAAS,GAAG,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC;IACzC,MAAM,qBAAqB,GAAG,MAAM,CAAC,MAAM,GAAG,CAAC,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,CAAC;IAE5E,MAAM,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;IAC1D,MAAM,SAAS,GAAG,OAAO,CAAC,KAAK,CAAC,iBAAiB,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;IACtE,MAAM,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;IAC/D,MAAM,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;IACjE,MAAM,UAAU,GAAG,IAAI,EAAE,UAAU,IAAI,KAAK,CAAC;IAC7C,MAAM,aAAa,GAAG,IAAI,EAAE,aAAa,IAAI,EAAE,CAAC;IAChD,MAAM,uBAAuB,GAAG,UAAU,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC,CAAC;IAEvE,MAAM,gBAAgB,GAAuB,EAAE,CAAC;IAChD,IAAI,CAAC,WAAW;QAAE,gBAAgB,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,EAAE,uBAAuB,EAAE,CAAC,CAAC;IACxG,IAAI,CAAC,OAAO;QAAE,gBAAgB,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,aAAa,EAAE,CAAC,CAAC;IACrF,IAAI,CAAC,SAAS;QAAE,gBAAgB,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,EAAE,qBAAqB,CAAC,CAAC,CAAC,0BAA0B,CAAC,CAAC,CAAC,cAAc,EAAE,CAAC,CAAC;IAC/I,IAAI,CAAC,OAAO;QAAE,gBAAgB,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,qBAAqB,EAAE,CAAC,CAAC;IAC7F,IAAI,CAAC,SAAS;QAAE,gBAAgB,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,CAAC,CAAC;IACzF,IAAI,CAAC,OAAO;QAAE,gBAAgB,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,aAAa,EAAE,CAAC,CAAC;IACrF,IAAI,CAAC,QAAQ;QAAE,gBAAgB,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,EAAE,cAAc,EAAE,CAAC,CAAC;IACxF,IAAI,CAAC,uBAAuB;QAAE,gBAAgB,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,2BAA2B,EAAE,MAAM,EAAE,0BAA0B,EAAE,CAAC,CAAC;IAEpI,MAAM,eAAe,GAAG,WAAW,CAAC,CAAC,CAAC,EAAE,eAAe,IAAI,CAAC,qBAAqB,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IAE5H,MAAM,UAAU,GAAwB;QACtC,EAAE,SAAS,EAAE,cAAc,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,aAAa,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,mBAAmB,EAAE;QACvH,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,eAAe,OAAO,CAAC,WAAW,eAAe,EAAE;QAClG,EAAE,SAAS,EAAE,WAAW,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,GAAG,WAAW,CAAC,MAAM,sBAAsB,MAAM,CAAC,MAAM,EAAE,EAAE,eAAe,EAAE;QAChI,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,0CAA0C,OAAO,CAAC,OAAO,CAAC,MAAM,GAAG,EAAE;QACpH,EAAE,SAAS,EAAE,WAAW,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,oBAAoB,EAAE;QACzE,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,cAAc,OAAO,CAAC,UAAU,CAAC,EAAE,EAAE,EAAE;QACtF,EAAE,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,cAAc,OAAO,CAAC,UAAU,CAAC,EAAE,EAAE,EAAE;QACxF,EAAE,SAAS,EAAE,2BAA2B,EAAE,KAAK,EAAE,uBAAuB,EAAE,KAAK,EAAE,cAAc,UAAU,cAAc,aAAa,CAAC,MAAM,EAAE,EAAE;KAChJ,CAAC;IAEF,oGAAoG;IACpG,uEAAuE;IACvE,MAAM,SAAS,GAAG,WAAW,IAAI,OAAO,IAAI,SAAS,IAAI,OAAO,IAAI,SAAS,IAAI,OAAO,CAAC;IAEzF,OAAO;QACL,SAAS;QACT,WAAW,EAAE,OAAO,CAAC,WAAW;QAChC,WAAW,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU;QAClF,aAAa;QACb,SAAS;QACT,gBAAgB;QAChB,QAAQ,EAAE;YACR,QAAQ,EAAE,OAAO,CAAC,KAAK,CAAC,QAAQ;YAChC,WAAW,EAAE,OAAO,CAAC,WAAW;YAChC,SAAS;YACT,UAAU,EAAE,OAAO,CAAC,UAAU,CAAC,EAAE;YACjC,aAAa,EAAE,OAAO,CAAC,OAAO,CAAC,MAAM;YACrC,UAAU;SACX;KACF,CAAC;AACJ,CAAC"}

package/dist/world/projection/evidence-profile.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Projection evidence profile (EXPERIMENTAL, internal).
+ *
+ * `ProjectionContract` currently carries more explanatory weight than any other Stage-2 concept, and
+ * its claims are NOT equally supported. This file grades each one, because a clean API plus a passing
+ * fixture reads exactly like evidence while often being neither.
+ *
+ * The grade that matters is the middle one:
+ *
+ *   experimentally-grounded  — supported by a result produced by an INDEPENDENTLY built component,
+ *                              or by an ablation that changed an outcome
+ *   fixture-supported        — a test I wrote passes against an API I designed. This is a consistency
+ *                              check, not evidence. It cannot falsify the design it was written from
+ *   architectural-hypothesis — asserted by the design, untested. Currently indistinguishable from
+ *                              a good guess
+ *
+ * Most projection fixtures are `fixture-supported`. Saying so is the point: Stage 1 treated Opportunity
+ * this way and it is why `Ω_sys` is trustworthy now.
+ */
+import type { PredictionId } from '../conformance/predictions.ts';
+import type { EvidenceGrade, EvidenceProvenance, Independence } from '../conformance/evidence.ts';
+export type { EvidenceGrade } from '../conformance/evidence.ts';
+export interface ProjectionClaim {
+    readonly id: string;
+    readonly claim: string;
+    readonly grade: EvidenceGrade;
+    /** WHERE the support comes from - a separate dimension from how settled the claim is. */
+    readonly provenance: EvidenceProvenance;
+    readonly basis: string;
+    /** The experiment that would move this claim up a grade. Every ungrounded claim must name one. */
+    readonly wouldBeGroundedBy: string;
+    /** The registered prediction that will test it, once one exists. */
+    readonly prediction?: PredictionId;
+}
+export declare function projectionClaims(): ProjectionClaim[];
+export interface EvidenceProfile {
+    readonly grounded: number;
+    readonly fixtureSupported: number;
+    readonly hypotheses: number;
+    /** Ratio of claims backed by something that could have come out otherwise. */
+    readonly groundedFraction: number;
+    /** Every ungrounded claim names the experiment that would ground it. */
+    readonly allUngroundedHaveAPath: boolean;
+    /** Claims whose support has high or medium independence - could have come out otherwise. */
+    readonly independentlySupported: number;
+    readonly byIndependence: Readonly<Record<Independence, number>>;
+    /** Maturity never outruns provenance. */
+    readonly consistent: boolean;
+}
+export declare function projectionEvidenceProfile(): EvidenceProfile;
+//# sourceMappingURL=evidence-profile.d.ts.map

package/dist/world/projection/evidence-profile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evidence-profile.d.ts","sourceRoot":"","sources":["../../../src/world/projection/evidence-profile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAElE,OAAO,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAElG,YAAY,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAEhE,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,yFAAyF;IACzF,QAAQ,CAAC,UAAU,EAAE,kBAAkB,CAAC;IACxC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,kGAAkG;IAClG,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,oEAAoE;IACpE,QAAQ,CAAC,UAAU,CAAC,EAAE,YAAY,CAAC;CACpC;AAED,wBAAgB,gBAAgB,IAAI,eAAe,EAAE,CA4EpD;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,8EAA8E;IAC9E,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,wEAAwE;IACxE,QAAQ,CAAC,sBAAsB,EAAE,OAAO,CAAC;IACzC,4FAA4F;IAC5F,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAC;IACxC,QAAQ,CAAC,cAAc,EAAE,QAAQ,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC;IAChE,yCAAyC;IACzC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;CAC9B;AAED,wBAAgB,yBAAyB,IAAI,eAAe,CAgB3D"}

package/dist/world/projection/evidence-profile.js

@@ -0,0 +1,93 @@
+import { independenceOf, gradeProvenanceProblems } from "../conformance/evidence.js";
+export function projectionClaims() {
+    return [
+        {
+            id: 'existence',
+            claim: 'projection is not observation — it is a distinct concept',
+            grade: 'experimentally-grounded',
+            provenance: 'emerged-from-prior-mechanism',
+            basis: 'F1.8 ablation: substituting observation for projection materially changed Ω_sys over identical state. The Ω_sys evaluator was built independently, in F1.6, before ProjectionContract existed — so it could have failed to show a difference',
+            wouldBeGroundedBy: 'already grounded; replication with a second opportunity model would strengthen it',
+        },
+        {
+            id: 'omega-coupling',
+            claim: 'a projection changes Ω_sys without changing world state',
+            grade: 'experimentally-grounded',
+            provenance: 'emerged-from-prior-mechanism',
+            basis: 'two surfaces over one identical snapshot produced different `signaled` and identical `available`, measured through the F1.6 evaluator rather than through projection code',
+            wouldBeGroundedBy: 'already grounded',
+        },
+        {
+            id: 'boundary',
+            claim: 'hidden state remains in the world but is absent from the surface, and cannot be reached through it',
+            grade: 'fixture-supported',
+            provenance: 'fixture-against-same-implementation',
+            basis: 'projection-relative invariants reading hidden state return unevaluable-outside-surface — but the check and the surface were designed together',
+            wouldBeGroundedBy: 'an adversarial probe written against the surface WITHOUT knowledge of its implementation, attempting to recover a hidden value through any exposed path (evidence, invariants, anomalies, operation records)',
+        },
+        {
+            id: 'power-restriction',
+            claim: 'a projection cannot manufacture capability or silently grant permission',
+            grade: 'fixture-supported',
+            provenance: 'fixture-against-same-implementation',
+            basis: 'exposure never adds to effectiveCapabilities and presentation never adds to effectiveAuthority — proven only for the definitions I wrote, over a single projection layer',
+            wouldBeGroundedBy: 'projection composition: whether the guarantee survives projecting a projection, where a second layer might launder what the first withheld',
+            prediction: 'P-006',
+        },
+        {
+            id: 'authority-presentation',
+            claim: 'presented authority is fully separable from effective authority, including delegation',
+            grade: 'architectural-hypothesis',
+            provenance: 'architectural-argument',
+            basis: 'only understatement and overstatement over direct grants have been exercised; delegated and derived authority are untested',
+            wouldBeGroundedBy: 'a substrate or scenario with real delegated authority, where the grant chain has more than one link',
+            prediction: 'P-005',
+        },
+        {
+            id: 'evidence-visibility',
+            claim: 'evidence access is a projection-relative property that composes correctly',
+            grade: 'architectural-hypothesis',
+            provenance: 'architectural-argument',
+            basis: 'accessible/withheld is honoured for one projection over one source; nothing tests chained access or provenance survival',
+            wouldBeGroundedBy: 'chained projections where the second layer requests evidence the first withheld',
+            prediction: 'P-006',
+        },
+        {
+            id: 'participant-relative-state',
+            claim: 'participant-relative state needs no participant model — it reduces to observation access plus scope',
+            grade: 'architectural-hypothesis',
+            provenance: 'architectural-argument',
+            basis: 'scope is currently a label carried through the surface; no result depends on it',
+            wouldBeGroundedBy: 'a scenario where two participants share a projection definition but must see different state, forcing scope to do real work',
+            prediction: 'P-007',
+        },
+        {
+            id: 'invariant-scope',
+            claim: 'projection-relative invariants are correctly scoped to the surface',
+            grade: 'architectural-hypothesis',
+            provenance: 'architectural-argument',
+            basis: 'unevaluable-outside-surface is enforced, but the foundation does not distinguish unevaluable from vacuously satisfied — a claim over an empty surface is currently indistinguishable from one that genuinely holds',
+            wouldBeGroundedBy: 'invariants over surfaces that expose none of the keys they read, checked against a model that knows the true answer',
+            prediction: 'P-008',
+        },
+    ];
+}
+export function projectionEvidenceProfile() {
+    const claims = projectionClaims();
+    const by = (g) => claims.filter((c) => c.grade === g).length;
+    const ungrounded = claims.filter((c) => c.grade !== 'experimentally-grounded');
+    const byIndependence = { high: 0, medium: 0, low: 0, none: 0 };
+    for (const c of claims)
+        byIndependence[independenceOf(c.provenance)] += 1;
+    return {
+        grounded: by('experimentally-grounded'),
+        fixtureSupported: by('fixture-supported'),
+        hypotheses: by('architectural-hypothesis'),
+        groundedFraction: by('experimentally-grounded') / claims.length,
+        allUngroundedHaveAPath: ungrounded.every((c) => c.wouldBeGroundedBy.length > 0),
+        independentlySupported: byIndependence.high + byIndependence.medium,
+        byIndependence,
+        consistent: claims.every((c) => gradeProvenanceProblems(c.grade, c.provenance).length === 0),
+    };
+}
+//# sourceMappingURL=evidence-profile.js.map

package/dist/world/projection/evidence-profile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"evidence-profile.js","sourceRoot":"","sources":["../../../src/world/projection/evidence-profile.ts"],"names":[],"mappings":"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"}

package/dist/world/projection/projection.d.ts

@@ -0,0 +1,162 @@
+/**
+ * F2 foundation — `ProjectionContract` (EXPERIMENTAL, internal, not exported from the package entry).
+ *
+ * A projection is how a world is PRESENTED to a participant or consumer. It is deliberately kept
+ * distinct from six neighbouring concepts that are easy to collapse:
+ *
+ *   observation    — what state can be read           (≠ what operations are offered)
+ *   snapshot       — a serialized reading of state    (≠ a presentation of a world)
+ *   evidence       — the record of what was observed  (≠ access to that record)
+ *   capability     — what execution CAN occur         (a projection can never create it)
+ *   authority      — what MAY occur, and by whose say (a projection can never grant it)
+ *   operation availability — whether an operation can be invoked to effect NOW
+ *
+ * The load-bearing rule: **a projection is subtractive with respect to power**. It may hide, withhold,
+ * relabel and understate; it may never manufacture a capability or silently grant permission. Where a
+ * definition claims more than the source holds, the surface still reflects the SOURCE and the excess is
+ * reported as an anomaly — never resolved in the projection's favour.
+ *
+ * A projection CAN change Ω_sys (system-relative opportunity) without changing world state, because
+ * `exposed` and `signaled` are projection-relative predicates. That is the point, not a defect.
+ *
+ * Participant belief, perception, interpretation and understanding are NOT modelled here — they are
+ * empirically inferred (M1.5-01). Where a claim would require them, an unresolved obligation is emitted.
+ */
+import type { WorldVersionEnvelope } from '../envelope.ts';
+import type { WorldStateSnapshot } from '../world.ts';
+import type { AuthorityGrant, OperationDecl, OpportunityProjection } from '../opportunity/opportunity.ts';
+export interface ProjectionIdentity {
+    readonly id: string;
+    readonly version: string;
+}
+/** Who the projection is FOR. A consumer need not be a person. */
+export interface ProjectionScope {
+    readonly consumer: string;
+    readonly kind: 'participant' | 'agent' | 'diagnostic' | 'external-system';
+}
+/** What state may be READ. Distinct from {@link OperationExposure} — reading is not acting. */
+export interface ObservationAccess {
+    readonly observable: readonly string[];
+    /** Present in the world, deliberately withheld from this surface. NOT the same as absent. */
+    readonly hidden: readonly string[];
+}
+/**
+ * Three genuinely different states:
+ *   exposed     — offered on this surface
+ *   hidden      — exists in the world, deliberately not offered here
+ *   unavailable — does not exist in the world at all
+ * Collapsing `hidden` into `unavailable` would let a projection misrepresent the world's vocabulary.
+ */
+export type OperationExposureState = 'exposed' | 'hidden' | 'unavailable';
+export interface OperationExposure {
+    readonly exposed: readonly string[];
+    readonly hidden: readonly string[];
+    /** Discoverability. A subset of `exposed`: nothing can be signaled that is not offered. */
+    readonly signaled: readonly string[];
+}
+/** Access to the evidence record — distinct from the evidence itself. */
+export interface EvidenceAccess {
+    readonly accessible: readonly string[];
+    readonly withheld: readonly string[];
+}
+/**
+ * What the surface PRESENTS about permission. Presenting less than the source holds is a legitimate
+ * projection choice (understatement). Presenting more is an anomaly and never takes effect.
+ */
+export interface AuthorityPresentation {
+    readonly presented: readonly string[];
+}
+export interface ProjectionTransform {
+    readonly id: string;
+    readonly kind: 'filter' | 'rename' | 'aggregate' | 'derive' | 'redact';
+    readonly detail: string;
+}
+/** An invariant evaluated against the SURFACE, never against hidden world state. */
+export interface ProjectionInvariant {
+    readonly id: string;
+    readonly statement: string;
+    /** Surface keys the claim reads. Anything outside the surface makes it unevaluable here. */
+    readonly reads: readonly string[];
+}
+export interface ProjectionDefinition {
+    readonly identity: ProjectionIdentity;
+    readonly sourceEnvelope: WorldVersionEnvelope;
+    readonly scope: ProjectionScope;
+    readonly observation: ObservationAccess;
+    readonly operations: OperationExposure;
+    readonly evidence: EvidenceAccess;
+    readonly authority: AuthorityPresentation;
+    readonly invariants: readonly ProjectionInvariant[];
+    readonly provenance: readonly ProjectionTransform[];
+}
+/** The ground truth a projection is taken OF. The projection never writes back to it. */
+export interface ProjectionSource {
+    readonly envelope: WorldVersionEnvelope;
+    readonly operations: readonly OperationDecl[];
+    readonly snapshot: WorldStateSnapshot;
+    /** What execution can actually occur (capability, NOT permission). */
+    readonly capabilities: readonly string[];
+    readonly authority: readonly AuthorityGrant[];
+    readonly evidenceIds: readonly string[];
+}
+export type ProjectionAnomalyCode = 'capability-not-manufacturable' | 'authority-overstated' | 'exposed-operation-absent-from-world' | 'exposed-and-hidden-conflict' | 'signaled-without-exposure' | 'observation-key-absent-from-world' | 'envelope-mismatch';
+export interface ProjectionAnomaly {
+    readonly code: ProjectionAnomalyCode;
+    readonly subject: string;
+    readonly detail: string;
+}
+/** Something the runtime cannot decide. Never silently discharged. */
+export interface ProjectionObligation {
+    readonly id: string;
+    readonly claim: string;
+    readonly authority: string;
+    readonly status: 'unresolved';
+}
+export interface OperationExposureRecord {
+    readonly operation: string;
+    readonly exposure: OperationExposureState;
+    readonly signaled: boolean;
+}
+export interface ProjectionSurface {
+    readonly identity: ProjectionIdentity;
+    readonly sourceEnvelope: WorldVersionEnvelope;
+    readonly scope: ProjectionScope;
+    /** Filtered state. Hidden keys are ABSENT here while remaining present in the world. */
+    readonly observedState: Readonly<Record<string, number>>;
+    readonly hiddenStateKeys: readonly string[];
+    readonly operations: readonly OperationExposureRecord[];
+    /** Always a subset of the source's capabilities — the subtractive rule, enforced. */
+    readonly effectiveCapabilities: readonly string[];
+    /** Always a subset of the source's valid grants — a projection cannot grant. */
+    readonly effectiveAuthority: readonly AuthorityGrant[];
+    /** What the surface CLAIMS about permission; may differ from `effectiveAuthority`. */
+    readonly presentedAuthority: readonly string[];
+    readonly accessibleEvidence: readonly string[];
+    readonly invariants: readonly ProjectionInvariant[];
+    readonly provenance: readonly ProjectionTransform[];
+}
+export interface ProjectionResult {
+    readonly surface: ProjectionSurface;
+    readonly anomalies: readonly ProjectionAnomaly[];
+    readonly obligations: readonly ProjectionObligation[];
+}
+/**
+ * Apply a definition to a source. Pure: returns a surface plus every discrepancy found, and never
+ * mutates or "repairs" the source in the projection's favour.
+ */
+export declare function project(definition: ProjectionDefinition, source: ProjectionSource): ProjectionResult;
+/** Bridge to Ω_sys (F1.6): the projection-relative half of opportunity, derived from the surface. */
+export declare function toOpportunityProjection(surface: ProjectionSurface): OpportunityProjection;
+export type ProjectionInvariantStatus = 'satisfied' | 'violated' | 'unevaluable-outside-surface';
+export interface ProjectionInvariantResult {
+    readonly id: string;
+    readonly status: ProjectionInvariantStatus;
+    readonly reason: string;
+}
+/**
+ * Evaluate projection-relative invariants against the SURFACE only. A claim that reads a key which is
+ * not on the surface is `unevaluable-outside-surface` — it is never silently satisfied by reaching into
+ * hidden world state.
+ */
+export declare function checkProjectionInvariants(surface: ProjectionSurface, predicate: (id: string, observed: Readonly<Record<string, number>>) => boolean): ProjectionInvariantResult[];
+//# sourceMappingURL=projection.d.ts.map

package/dist/world/projection/projection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projection.d.ts","sourceRoot":"","sources":["../../../src/world/projection/projection.ts"],"names":[],"mappings":"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"}

package/dist/world/projection/projection.js

@@ -0,0 +1,145 @@
+function validGrant(g) {
+    return g.authoritySource.length > 0 && g.authoritySource !== 'unknown';
+}
+/**
+ * Apply a definition to a source. Pure: returns a surface plus every discrepancy found, and never
+ * mutates or "repairs" the source in the projection's favour.
+ */
+export function project(definition, source) {
+    const anomalies = [];
+    const obligations = [];
+    if (definition.sourceEnvelope.worldInstance !== source.envelope.worldInstance) {
+        anomalies.push({
+            code: 'envelope-mismatch',
+            subject: definition.identity.id,
+            detail: `definition targets ${definition.sourceEnvelope.worldInstance}, source is ${source.envelope.worldInstance}`,
+        });
+    }
+    // --- observation: hidden keys are removed from the surface but remain in the world snapshot
+    const worldMetrics = source.snapshot.metrics;
+    const hiddenSet = new Set(definition.observation.hidden);
+    const observedState = {};
+    for (const key of definition.observation.observable) {
+        if (!(key in worldMetrics)) {
+            anomalies.push({ code: 'observation-key-absent-from-world', subject: key, detail: 'observable key is not present in the source snapshot' });
+            continue;
+        }
+        if (hiddenSet.has(key)) {
+            anomalies.push({ code: 'exposed-and-hidden-conflict', subject: key, detail: 'key declared both observable and hidden' });
+            continue;
+        }
+        observedState[key] = worldMetrics[key];
+    }
+    // --- operations: exposed / hidden / unavailable are kept genuinely distinct
+    const worldOps = new Set(source.operations.map((o) => o.id));
+    const exposedSet = new Set(definition.operations.exposed);
+    const hiddenOps = new Set(definition.operations.hidden);
+    const signaledSet = new Set(definition.operations.signaled);
+    for (const op of exposedSet) {
+        if (!worldOps.has(op)) {
+            anomalies.push({ code: 'exposed-operation-absent-from-world', subject: op, detail: 'projection exposes an operation the world does not declare' });
+        }
+        if (hiddenOps.has(op)) {
+            anomalies.push({ code: 'exposed-and-hidden-conflict', subject: op, detail: 'operation declared both exposed and hidden' });
+        }
+    }
+    for (const op of signaledSet) {
+        if (!exposedSet.has(op)) {
+            anomalies.push({ code: 'signaled-without-exposure', subject: op, detail: 'an operation cannot be signaled without being exposed' });
+        }
+    }
+    const allOps = new Set([...worldOps, ...exposedSet, ...hiddenOps]);
+    const operations = [...allOps].sort().map((op) => {
+        const exposure = !worldOps.has(op)
+            ? 'unavailable' // not in the world at all — distinct from being hidden
+            : hiddenOps.has(op)
+                ? 'hidden' // exists, deliberately not offered here
+                : exposedSet.has(op)
+                    ? 'exposed'
+                    : 'hidden'; // not offered on this surface ⇒ hidden, never "unavailable"
+        return { operation: op, exposure, signaled: exposure === 'exposed' && signaledSet.has(op) };
+    });
+    // --- capability: strictly subtractive. Exposure never creates the ability to execute.
+    const effectiveCapabilities = source.capabilities.filter((c) => exposedSet.has(c));
+    for (const op of exposedSet) {
+        if (!source.capabilities.includes(op)) {
+            anomalies.push({
+                code: 'capability-not-manufacturable',
+                subject: op,
+                detail: 'operation is exposed but the source holds no capability for it; exposure does not create one',
+            });
+        }
+    }
+    // --- authority: presenting less is legitimate; presenting more is reported and never takes effect
+    const validGrants = source.authority.filter(validGrant);
+    const grantedOps = new Set(validGrants.map((g) => g.operation));
+    const effectiveAuthority = validGrants.filter((g) => exposedSet.has(g.operation));
+    for (const op of definition.authority.presented) {
+        if (!grantedOps.has(op)) {
+            anomalies.push({
+                code: 'authority-overstated',
+                subject: op,
+                detail: 'projection presents permission the source does not grant; presentation does not confer permission',
+            });
+        }
+    }
+    // --- evidence access
+    const withheld = new Set(definition.evidence.withheld);
+    const accessibleEvidence = definition.evidence.accessible.filter((e) => source.evidenceIds.includes(e) && !withheld.has(e));
+    // The runtime reports what is signaled; it must NOT claim the consumer perceived or understood it.
+    if (signaledSet.size > 0) {
+        obligations.push({
+            id: `perception:${definition.identity.id}`,
+            claim: 'signaled operations are perceived, understood, or expected by the consumer',
+            authority: 'empirical',
+            status: 'unresolved',
+        });
+    }
+    return {
+        surface: {
+            identity: definition.identity,
+            sourceEnvelope: source.envelope,
+            scope: definition.scope,
+            observedState,
+            hiddenStateKeys: [...hiddenSet].filter((k) => k in worldMetrics),
+            operations,
+            effectiveCapabilities,
+            effectiveAuthority,
+            presentedAuthority: definition.authority.presented,
+            accessibleEvidence,
+            invariants: definition.invariants,
+            provenance: definition.provenance,
+        },
+        anomalies,
+        obligations,
+    };
+}
+/** Bridge to Ω_sys (F1.6): the projection-relative half of opportunity, derived from the surface. */
+export function toOpportunityProjection(surface) {
+    return {
+        id: surface.identity.id,
+        exposed: surface.operations.filter((o) => o.exposure === 'exposed').map((o) => o.operation),
+        signaled: surface.operations.filter((o) => o.signaled).map((o) => o.operation),
+    };
+}
+/**
+ * Evaluate projection-relative invariants against the SURFACE only. A claim that reads a key which is
+ * not on the surface is `unevaluable-outside-surface` — it is never silently satisfied by reaching into
+ * hidden world state.
+ */
+export function checkProjectionInvariants(surface, predicate) {
+    return surface.invariants.map((inv) => {
+        const missing = inv.reads.filter((k) => !(k in surface.observedState));
+        if (missing.length > 0) {
+            return {
+                id: inv.id,
+                status: 'unevaluable-outside-surface',
+                reason: `reads ${missing.join(', ')} which are not on this surface`,
+            };
+        }
+        return predicate(inv.id, surface.observedState)
+            ? { id: inv.id, status: 'satisfied', reason: 'holds against the projection surface' }
+            : { id: inv.id, status: 'violated', reason: 'fails against the projection surface' };
+    });
+}
+//# sourceMappingURL=projection.js.map