yarramate 0.21.0 → 0.23.0

package/catalogues/core-enrichment.yaml

@@ -1,12 +1,13 @@
 format: yarramate/question-catalogue/v1
 id: core-enrichment
-version: "0.8"
+version: "0.9"
 profile: yarramate/core@0.1
 presentation:
   title: Core enrichment interview
   description: >-
-    The guided design path: motivation, business, application, technology,
-    and implementation waves plus cross-cutting hygiene. Each question
+    The guided design path: motivation, interaction, business, application,
+    technology, and implementation waves plus cross-cutting hygiene. Each
+    question
     states the decision its answer changes; a question that cannot is
     deleted, not softened. Adequacy is enforced by linkage depth and
     attestation, never by reading words. Versioning is additive within a
@@ -18,6 +19,12 @@ waves:
   - id: motivation
     name: Motivation
     description: Why the system exists and what constrains it.
+  - id: interaction
+    name: Interaction
+    description: >-
+      Load-bearing hops: the behavior a component is assigned to, the
+      serving/triggering/flow mechanism, payload, trust, reliability, and
+      capacity. Hygiene waits.
   - id: business
     name: Business
     description: Who acts, what is served, and what information matters.
@@ -333,6 +340,398 @@ questions:
       attestation with topic "adequacy" (revoke by deleting it; Git
       reviews both).
 
+  # ---- interaction ---------------------------------------------------------
+  - id: authn-standard-missing
+    wave: interaction
+    since: "0.9"
+    scope: workspace
+    trigger:
+      - condition: exists-linkage
+        kinds:
+          - yarramate/core@0.1#serving
+          - yarramate/core@0.1#flow
+          - yarramate/core@0.1#triggering
+        direction: either
+        counterpartKinds:
+          - yarramate/core@0.1#applicationComponent
+          - yarramate/core@0.1#applicationInterface
+          - yarramate/core@0.1#businessActor
+      - condition: no-subject-of-kind
+        kinds:
+          - yarramate/policy@0.1#authentication-constraint
+    question: >-
+      What is the default authentication mechanism for interactions in this
+      architecture?
+    askPlain: >-
+      When one system talks to another here, how do they prove who they
+      are? Pick the default now so each hop is not inventing its own.
+    materiality: >-
+      An unauthenticated hop to another system is a trust-boundary decision
+      nobody recorded. Implementers will pick a mechanism in code, and the
+      next hop will assume a different one. This question does not cover
+      authorization or transport security.
+    authority: human
+    resolution: >-
+      Add an authentication-constraint (the standard, or a not-applicable
+      subject with the reason in its description) in a document that
+      selects yarramate/policy@0.1.
+
+  - id: ratelimit-standard-missing
+    wave: interaction
+    since: "0.9"
+    scope: workspace
+    trigger:
+      - condition: exists-linkage
+        kinds:
+          - yarramate/core@0.1#serving
+        direction: either
+        counterpartKinds:
+          - yarramate/core@0.1#businessActor
+      - condition: no-subject-of-kind
+        kinds:
+          - yarramate/policy@0.1#rate-limit-constraint
+    question: >-
+      Where is rate limiting a requirement, and what is the default rule?
+    askPlain: >-
+      Do caller-facing APIs have a capacity cap? If yes, what is it? If
+      no, say so so we do not keep asking per hop.
+    materiality: >-
+      Caller-facing hops without a capacity rule are sized by whoever
+      implements first. An explicit none is a decision; silence is not.
+    authority: human
+    resolution: >-
+      Add a rate-limit-constraint for the default cap, or a
+      ratelimit-not-applicable subject. Bind hop-specific values with
+      expects on the binding.
+
+  - id: reliability-standard-missing
+    wave: interaction
+    since: "0.9"
+    scope: workspace
+    trigger:
+      - condition: exists-linkage
+        kinds:
+          - yarramate/core@0.1#flow
+          - yarramate/core@0.1#triggering
+        direction: either
+        counterpartKinds:
+          - yarramate/core@0.1#applicationComponent
+          - yarramate/core@0.1#applicationInterface
+          - yarramate/core@0.1#applicationProcess
+          - yarramate/core@0.1#applicationFunction
+          - yarramate/core@0.1#applicationInteraction
+          - yarramate/core@0.1#applicationEvent
+          - yarramate/core@0.1#businessActor
+      - condition: no-subject-of-kind
+        kinds:
+          - yarramate/policy@0.1#reliability-constraint
+    question: >-
+      What is the default delivery, retry, and idempotency rule for
+      asynchronous or content-moving interactions?
+    askPlain: >-
+      When a message or payload does not arrive, do we retry, and what
+      makes a retry safe to repeat?
+    materiality: >-
+      Retry without idempotency duplicates work; no retry without a
+      recorded choice leaves timeout behaviour to each implementer.
+    authority: human
+    resolution: >-
+      Add a reliability-constraint (the standard, or not-applicable with
+      the reason in its description).
+
+  - id: hop-unrealised
+    wave: interaction
+    since: "0.9"
+    scope: subject
+    subjects:
+      kinds:
+        - yarramate/core@0.1#applicationComponent
+      statuses:
+        - planned
+        - current
+    trigger:
+      - condition: has-linkage
+        kinds:
+          - yarramate/core@0.1#serving
+          - yarramate/core@0.1#flow
+          - yarramate/core@0.1#triggering
+        direction: either
+        counterpartKinds:
+          - yarramate/core@0.1#applicationComponent
+          - yarramate/core@0.1#applicationInterface
+          - yarramate/core@0.1#businessActor
+      - condition: missing-linkage
+        kinds:
+          - yarramate/core@0.1#assignment
+        direction: outgoing
+        counterpartKinds:
+          - yarramate/core@0.1#applicationProcess
+          - yarramate/core@0.1#applicationFunction
+          - yarramate/core@0.1#applicationInteraction
+          - yarramate/core@0.1#applicationEvent
+          - yarramate/core@0.1#applicationInterface
+    question: >-
+      {subject.name} participates in an application interaction, but
+      nothing it is assigned to is that interaction. What process,
+      function, interaction, event, or interface is the hop?
+    askPlain: >-
+      {subject.name} talks to something else, but the model never names
+      the work it does in that talk. What is the actual step?
+    materiality: >-
+      A component-to-component edge with no assigned behavior is
+      inventory. Protocol, trust, payload, and failure have nowhere to
+      bind until the hop is a subject.
+    authority: either
+    resolution: >-
+      Add an application process, function, interaction, event, or
+      interface, assign this component to it, and relate that behavior
+      with serving, triggering, or flow to its counterpart. Do not answer
+      by deleting the component or adding a realization instead.
+
+  - id: interaction-protocol-unbound
+    wave: interaction
+    since: "0.9"
+    scope: subject
+    subjects:
+      kinds:
+        - yarramate/core@0.1#applicationProcess
+        - yarramate/core@0.1#applicationFunction
+        - yarramate/core@0.1#applicationInteraction
+        - yarramate/core@0.1#applicationEvent
+        - yarramate/core@0.1#applicationInterface
+      statuses:
+        - planned
+        - current
+    trigger:
+      - condition: has-linkage
+        kinds:
+          - yarramate/core@0.1#serving
+        direction: either
+        counterpartKinds:
+          - yarramate/core@0.1#applicationComponent
+          - yarramate/core@0.1#applicationInterface
+          - yarramate/core@0.1#applicationProcess
+          - yarramate/core@0.1#applicationFunction
+          - yarramate/core@0.1#applicationInteraction
+          - yarramate/core@0.1#applicationEvent
+          - yarramate/core@0.1#businessActor
+      - condition: missing-constraint
+        kinds:
+          - yarramate/policy@0.1#mechanism-constraint
+    question: >-
+      {subject.name} is a serving hop. Which protocol is it — REST/HTTP,
+      SOAP, GraphQL, or something else?
+    askPlain: >-
+      When {subject.name} is called, what is the wire protocol?
+    materiality: >-
+      Serving names the pattern, not the contract. A REST hop and a SOAP
+      hop fail, version, and authenticate differently.
+    authority: either
+    resolution: >-
+      Bind a mechanism-constraint on this behavior (or a not-applicable
+      subject if the serving kind is already the whole answer).
+
+  - id: interaction-content-unknown
+    wave: interaction
+    since: "0.9"
+    scope: subject
+    subjects:
+      kinds:
+        - yarramate/core@0.1#applicationProcess
+        - yarramate/core@0.1#applicationFunction
+        - yarramate/core@0.1#applicationInteraction
+        - yarramate/core@0.1#applicationEvent
+        - yarramate/core@0.1#applicationInterface
+      statuses:
+        - planned
+        - current
+    trigger:
+      - condition: missing-flow-content
+    question: >-
+      {subject.name} sends a flow with no content. What moves?
+    askPlain: >-
+      {subject.name} sends something on. What is that something called?
+    materiality: >-
+      A flow with no content is an unnamed payload. Retry, scanning, and
+      the counterpart contract have nothing to name.
+    authority: either
+    resolution: >-
+      Set content on the flow relationship.
+
+  - id: interaction-contract-unknown
+    wave: interaction
+    since: "0.9"
+    scope: subject
+    subjects:
+      kinds:
+        - yarramate/core@0.1#applicationProcess
+        - yarramate/core@0.1#applicationFunction
+        - yarramate/core@0.1#applicationInteraction
+        - yarramate/core@0.1#applicationEvent
+        - yarramate/core@0.1#applicationInterface
+      statuses:
+        - planned
+        - current
+    trigger:
+      - condition: has-linkage
+        kinds:
+          - yarramate/core@0.1#serving
+          - yarramate/core@0.1#flow
+          - yarramate/core@0.1#triggering
+        direction: either
+        counterpartKinds:
+          - yarramate/core@0.1#applicationComponent
+          - yarramate/core@0.1#applicationInterface
+          - yarramate/core@0.1#applicationProcess
+          - yarramate/core@0.1#applicationFunction
+          - yarramate/core@0.1#applicationInteraction
+          - yarramate/core@0.1#applicationEvent
+          - yarramate/core@0.1#businessActor
+      - condition: missing-linkage
+        kinds:
+          - yarramate/core@0.1#access
+        direction: outgoing
+        counterpartKinds:
+          - yarramate/core@0.1#dataObject
+          - yarramate/core@0.1#contract
+    question: >-
+      {subject.name} participates in a hop but accesses no contract or
+      data object. What information does it read or write?
+    askPlain: >-
+      What record or contract is {subject.name} working with?
+    materiality: >-
+      Schema ownership, identifiers, and classification have nowhere to
+      attach until the hop names the information it moves.
+    authority: either
+    resolution: >-
+      Add access from this behavior to a dataObject or contract.
+
+  - id: interaction-trust-unbound
+    wave: interaction
+    since: "0.9"
+    scope: subject
+    subjects:
+      kinds:
+        - yarramate/core@0.1#applicationProcess
+        - yarramate/core@0.1#applicationFunction
+        - yarramate/core@0.1#applicationInteraction
+        - yarramate/core@0.1#applicationEvent
+        - yarramate/core@0.1#applicationInterface
+      statuses:
+        - planned
+        - current
+    trigger:
+      - condition: has-linkage
+        kinds:
+          - yarramate/core@0.1#serving
+          - yarramate/core@0.1#flow
+          - yarramate/core@0.1#triggering
+        direction: either
+        counterpartKinds:
+          - yarramate/core@0.1#applicationComponent
+          - yarramate/core@0.1#applicationInterface
+          - yarramate/core@0.1#applicationProcess
+          - yarramate/core@0.1#applicationFunction
+          - yarramate/core@0.1#applicationInteraction
+          - yarramate/core@0.1#applicationEvent
+          - yarramate/core@0.1#businessActor
+      - condition: missing-constraint
+        kinds:
+          - yarramate/policy@0.1#authentication-constraint
+    question: >-
+      How is trust established for {subject.name}?
+    askPlain: >-
+      Who does {subject.name} authenticate as, and with what?
+    materiality: >-
+      An unauthenticated hop to another system is a trust-boundary
+      decision nobody recorded. This is authentication only — not
+      authorization or transport security.
+    authority: either
+    resolution: >-
+      Bind an authentication-constraint on this behavior, or a
+      not-applicable subject if this hop is deliberately unauthenticated.
+
+  - id: interaction-reliability-unbound
+    wave: interaction
+    since: "0.9"
+    scope: subject
+    subjects:
+      kinds:
+        - yarramate/core@0.1#applicationProcess
+        - yarramate/core@0.1#applicationFunction
+        - yarramate/core@0.1#applicationInteraction
+        - yarramate/core@0.1#applicationEvent
+        - yarramate/core@0.1#applicationInterface
+      statuses:
+        - planned
+        - current
+    trigger:
+      - condition: has-linkage
+        kinds:
+          - yarramate/core@0.1#triggering
+          - yarramate/core@0.1#flow
+        direction: either
+        counterpartKinds:
+          - yarramate/core@0.1#applicationComponent
+          - yarramate/core@0.1#applicationInterface
+          - yarramate/core@0.1#applicationProcess
+          - yarramate/core@0.1#applicationFunction
+          - yarramate/core@0.1#applicationInteraction
+          - yarramate/core@0.1#applicationEvent
+          - yarramate/core@0.1#businessActor
+      - condition: missing-constraint
+        kinds:
+          - yarramate/policy@0.1#reliability-constraint
+    question: >-
+      What happens when {subject.name} fails — retry, idempotency,
+      dead-letter, compensation?
+    askPlain: >-
+      If {subject.name} does not finish, do we retry, and what makes a
+      retry safe?
+    materiality: >-
+      A content-moving hop without a reliability rule duplicates or
+      drops work at the first timeout.
+    authority: either
+    resolution: >-
+      Bind a reliability-constraint. A named failure process is stronger
+      and may come later; the constraint is the 0.9 closer.
+
+  - id: interaction-capacity-unbound
+    wave: interaction
+    since: "0.9"
+    scope: subject
+    subjects:
+      kinds:
+        - yarramate/core@0.1#applicationProcess
+        - yarramate/core@0.1#applicationFunction
+        - yarramate/core@0.1#applicationInteraction
+        - yarramate/core@0.1#applicationEvent
+        - yarramate/core@0.1#applicationInterface
+      statuses:
+        - planned
+        - current
+    trigger:
+      - condition: has-linkage
+        kinds:
+          - yarramate/core@0.1#serving
+        direction: either
+        counterpartKinds:
+          - yarramate/core@0.1#businessActor
+      - condition: missing-constraint
+        kinds:
+          - yarramate/policy@0.1#rate-limit-constraint
+    question: >-
+      What is the capacity rule for {subject.name}?
+    askPlain: >-
+      How hard may callers hit {subject.name}, or is there no cap?
+    materiality: >-
+      An Experience-facing hop without a capacity rule is sized by
+      whoever implements first. Explicit none is a decision.
+    authority: either
+    resolution: >-
+      Bind a rate-limit-constraint, with expects on the binding for the
+      numeric cap, or a not-applicable subject.
+
   # ---- business ------------------------------------------------------------
   - id: service-consumer-unknown
     wave: business

package/dist/adapters/visual-graph-entry.d.ts

@@ -0,0 +1 @@
+export { projectGraphForCanvas, type CanvasGraph, type CanvasNode, type CanvasEdge, } from '../graph-projection.js';

package/dist/adapters/visual-graph-entry.js

@@ -0,0 +1 @@
+export { projectGraphForCanvas, } from '../graph-projection.js';

package/dist/compiler.d.ts

@@ -108,24 +108,7 @@ export type IncrementalCompilationResult = ({
     readonly incremental: boolean;
     readonly cache: CompilationCache;
 };
-export declare const ATTESTATION_PREDICATE_PREFIX = "yarramate/attestation/";
-export declare const attestationClaimValue: (attestation: {
-    readonly by: string;
-    readonly on: string;
-    readonly recordedBy?: string;
-}) => string;
-export interface AttestationClaimParts {
-    readonly by: string;
-    readonly on: string;
-    readonly recordedBy?: string;
-}
-export declare const parseAttestationClaimValue: (value: string) => AttestationClaimParts | undefined;
-export interface ConstraintExpectsParts {
-    readonly provider: string;
-    readonly key: string;
-    readonly value: string;
-}
-export declare const parseConstraintExpectsValue: (value: string) => ConstraintExpectsParts | undefined;
+export { ATTESTATION_PREDICATE_PREFIX, attestationClaimValue, parseAttestationClaimValue, parseConstraintExpectsValue, type AttestationClaimParts, type ConstraintExpectsParts, } from './graph-claims.js';
 interface ResolvedPosition {
     readonly line: number;
     readonly col: number;
@@ -142,4 +125,3 @@ export declare const compileWorkspaceWithProfileContext: (sources: readonly Work
  * composed value per current source and drops sources that left the workspace.
  */
 export declare const compileWorkspaceIncremental: (sources: readonly WorkspaceSource[], previous?: CompilationCache) => IncrementalCompilationResult;
-export {};

package/dist/compiler.js

@@ -6,6 +6,8 @@ import documentSchema from '../schema/yarramate-document.schema.json' with { typ
 };
 import profileSchema from '../schema/yarramate-profile.schema.json' with { type: 'json'
 };
+import { ATTESTATION_PREDICATE_PREFIX, attestationClaimValue } from './graph-claims.js';
+import { shippedPolicyIdentity, shippedPolicySource, } from './shipped-profile.js';
 const coreProfile = 'yarramate/core@0.1';
 const require = createRequire(import.meta.url);
 const ajv2020Module = require('ajv/dist/2020.js');
@@ -39,41 +41,7 @@ const presenceClaimId = (subject, state) => `${subject}~present-in-${Buffer.from
 const aliasClaimId = (subject, alias) => `${subject}~alias-${Buffer.from(alias, 'utf8').toString('hex')}`;
 const distinctFromClaimId = (subject, other) => `${subject}~distinct-from-${Buffer.from(other, 'utf8').toString('hex')}`;
 const supersedesClaimId = (subject, predecessor) => `${subject}~supersedes-${Buffer.from(predecessor, 'utf8').toString('hex')}`;
-export const ATTESTATION_PREDICATE_PREFIX = 'yarramate/attestation/';
-// An attestation claim packs the authority, the date it was given, and
-// the recorder when a machine held the pen. A reference carries no
-// spaces and the date is fixed width, so the three parse back out of one
-// value unambiguously wherever a reader needs them.
-export const attestationClaimValue = (attestation) => attestation.recordedBy === undefined
-    ? `${attestation.by} ${attestation.on}`
-    : `${attestation.by} ${attestation.on} ${attestation.recordedBy}`;
-export const parseAttestationClaimValue = (value) => {
-    const match = /^(\S+) ([0-9]{4}-[0-9]{2}-[0-9]{2})(?: (.+))?$/.exec(value);
-    if (match === null)
-        return undefined;
-    const recordedBy = match[3];
-    return {
-        by: match[1],
-        on: match[2],
-        ...(recordedBy === undefined ? {} : { recordedBy }),
-    };
-};
-// Mirrors the compiler's own write-side encoding (ADR 0075): provider and
-// key admit no whitespace, so the first two spaces delimit them and
-// everything after the second space is the expected value verbatim, spaces
-// included. This is the sole authority for decoding the value written at
-// the constraint's `expects` claim — reconciliation.ts delegates here
-// rather than mirroring the regex itself.
-export const parseConstraintExpectsValue = (value) => {
-    const match = /^(\S+) (\S+) ([\s\S]+)$/.exec(value);
-    if (match === null)
-        return undefined;
-    return {
-        provider: match[1],
-        key: match[2],
-        value: match[3],
-    };
-};
+export { ATTESTATION_PREDICATE_PREFIX, attestationClaimValue, parseAttestationClaimValue, parseConstraintExpectsValue, } from './graph-claims.js';
 const describeAspect = (aspect) => aspect.replace('-', ' ');
 // Candidate order is the policy-matrix declaration order: the resolved kind
 // map inserts core policies first, then extension kinds as declared.
@@ -316,6 +284,46 @@ function compileWorkspaceResolved(parsed) {
         const identity = `${value.id}@${value.version}`;
         pendingProfiles.push({ input, value, identity, positionFor });
     }
+    const alreadyDeclaresPolicy = pendingProfiles.some(({ identity }) => identity === shippedPolicyIdentity);
+    if (!alreadyDeclaresPolicy) {
+        const selected = documentInputs.some(({ entry }) => {
+            const value = entry.value;
+            return value.profile === shippedPolicyIdentity;
+        });
+        const extended = pendingProfiles.some(({ value }) => value.extends === shippedPolicyIdentity);
+        if (selected || extended) {
+            const input = {
+                path: 'yarramate:profile:yarramate/policy@0.1',
+                source: shippedPolicySource,
+            };
+            const { entry, fresh } = parseWorkspaceSource(input);
+            const value = entry.value;
+            if (entry.schemaDiagnostics.length > 0) {
+                profileDiagnostics.push(...entry.schemaDiagnostics);
+            }
+            else if (!validateProfile(value)) {
+                for (const error of validateProfile.errors ?? []) {
+                    profileDiagnostics.push({
+                        severity: 'error',
+                        code: 'YM201',
+                        message: `Profile schema violation: ${describeSchemaViolation(error)}`,
+                        path: input.path,
+                        pointer: error.instancePath || '/',
+                        line: 1,
+                        column: 1,
+                    });
+                }
+            }
+            else {
+                pendingProfiles.push({
+                    input,
+                    value,
+                    identity: shippedPolicyIdentity,
+                    positionFor: positionReader(input.source, entry.positions, fresh),
+                });
+            }
+        }
+    }
     let unresolvedProfiles = pendingProfiles.sort((left, right) => left.identity.localeCompare(right.identity) ||
         left.input.path.localeCompare(right.input.path));
     while (unresolvedProfiles.length > 0) {

package/dist/graph-claims.d.ts

@@ -0,0 +1,18 @@
+export declare const ATTESTATION_PREDICATE_PREFIX = "yarramate/attestation/";
+export declare const attestationClaimValue: (attestation: {
+    readonly by: string;
+    readonly on: string;
+    readonly recordedBy?: string;
+}) => string;
+export interface AttestationClaimParts {
+    readonly by: string;
+    readonly on: string;
+    readonly recordedBy?: string;
+}
+export declare const parseAttestationClaimValue: (value: string) => AttestationClaimParts | undefined;
+export interface ConstraintExpectsParts {
+    readonly provider: string;
+    readonly key: string;
+    readonly value: string;
+}
+export declare const parseConstraintExpectsValue: (value: string) => ConstraintExpectsParts | undefined;

package/dist/graph-claims.js

@@ -0,0 +1,35 @@
+export const ATTESTATION_PREDICATE_PREFIX = 'yarramate/attestation/';
+// An attestation claim packs the authority, the date it was given, and
+// the recorder when a machine held the pen. A reference carries no
+// spaces and the date is fixed width, so the three parse back out of one
+// value unambiguously wherever a reader needs them.
+export const attestationClaimValue = (attestation) => attestation.recordedBy === undefined
+    ? `${attestation.by} ${attestation.on}`
+    : `${attestation.by} ${attestation.on} ${attestation.recordedBy}`;
+export const parseAttestationClaimValue = (value) => {
+    const match = /^(\S+) ([0-9]{4}-[0-9]{2}-[0-9]{2})(?: (.+))?$/.exec(value);
+    if (match === null)
+        return undefined;
+    const recordedBy = match[3];
+    return {
+        by: match[1],
+        on: match[2],
+        ...(recordedBy === undefined ? {} : { recordedBy }),
+    };
+};
+// Mirrors the compiler's own write-side encoding (ADR 0075): provider and
+// key admit no whitespace, so the first two spaces delimit them and
+// everything after the second space is the expected value verbatim, spaces
+// included. This is the sole authority for decoding the value written at
+// the constraint's `expects` claim — reconciliation.ts delegates here
+// rather than mirroring the regex itself.
+export const parseConstraintExpectsValue = (value) => {
+    const match = /^(\S+) (\S+) ([\s\S]+)$/.exec(value);
+    if (match === null)
+        return undefined;
+    return {
+        provider: match[1],
+        key: match[2],
+        value: match[3],
+    };
+};

package/dist/graph-projection.d.ts

@@ -1,12 +1,13 @@
-import { type ResolvedProfileContext, type SemanticGraph } from './compiler.js';
+import type { ResolvedProfileContext, SemanticGraph } from './compiler.js';
+import type { Aspect, Layer } from './profile.js';
 export interface CanvasNode {
     readonly id: string;
     readonly localId: string;
     readonly document: string;
     readonly kind: string;
     readonly kindLabel: string;
-    readonly layer: string | null;
-    readonly aspect: string | null;
+    readonly layer: Layer | null;
+    readonly aspect: Aspect | null;
     readonly name: string;
     readonly description: string | null;
     readonly aka: readonly string[];

package/dist/graph-projection.js

@@ -1,4 +1,4 @@
-import { ATTESTATION_PREDICATE_PREFIX, parseAttestationClaimValue, parseConstraintExpectsValue, } from './compiler.js';
+import { ATTESTATION_PREDICATE_PREFIX, parseAttestationClaimValue, parseConstraintExpectsValue, } from './graph-claims.js';
 import { kindLabelOf } from './kind-label.js';
 const CONCEPT_KIND_PREDICATE = 'yarramate/concept/kind';
 const CONCEPT_NAME_PREDICATE = 'yarramate/concept/name';

package/dist/interrogate-command.d.ts

@@ -18,6 +18,7 @@ type CatalogueCondition = {
 } | {
     readonly condition: 'no-subject-of-kind';
     readonly kinds: readonly string[];
+    readonly kindMatching?: 'exact' | 'descendants';
 } | {
     readonly condition: 'no-state-defined';
 } | {
@@ -26,6 +27,24 @@ type CatalogueCondition = {
     readonly direction: 'incoming' | 'outgoing';
     readonly counterpartKinds: readonly string[];
     readonly kindMatching?: 'exact' | 'descendants';
+} | {
+    readonly condition: 'has-linkage';
+    readonly kinds: readonly string[];
+    readonly direction: 'incoming' | 'outgoing' | 'either';
+    readonly counterpartKinds: readonly string[];
+    readonly kindMatching?: 'exact' | 'descendants';
+} | {
+    readonly condition: 'exists-linkage';
+    readonly kinds: readonly string[];
+    readonly direction: 'incoming' | 'outgoing' | 'either';
+    readonly counterpartKinds: readonly string[];
+    readonly kindMatching?: 'exact' | 'descendants';
+} | {
+    readonly condition: 'missing-constraint';
+    readonly kinds: readonly string[];
+    readonly kindMatching?: 'exact' | 'descendants';
+} | {
+    readonly condition: 'missing-flow-content';
 } | {
     readonly condition: 'missing-reference';
     readonly predicate: string;