@medicine-wheel/capabilities 0.0.0-stage → 0.21.0

package/README.md

@@ -1,3 +1,49 @@
-# Temporary Holding Version
+# @medicine-wheel/capabilities
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The platform-features and capabilities layer of the Medicine Wheel Developer Suite.
+
+A capability is something the platform can do for someone: publish a prototype to an
+episode, register a service, follow a wheel's events. It rides a `knowledge` node
+carrying `metadata.kind: "capability"` (direction west, `DEVELOPER_ENTITY_BINDING` in
+`ontology-core`), and this package holds its specifics keyed by node id, the way
+`@medicine-wheel/infra` holds a service's.
+
+## Install
+
+```bash
+npm install @medicine-wheel/capabilities
+```
+
+Depends on `@medicine-wheel/ontology-core`, `@medicine-wheel/infra` (for `MetisHold`) and `zod`.
+
+## What is here
+
+```ts
+import {
+  CapabilityFacetSchema,
+  checkStatement,
+  findSharedCapabilities,
+  type CapabilityFacet,
+  type Attribution,
+} from '@medicine-wheel/capabilities';
+```
+
+| Export | What it does |
+|---|---|
+| `CapabilityFacet`, `CapabilityFacetSchema` | One capability: id `capability:<slug>`, name, statement, status, providers, attribution. |
+| `Attribution`, `attributionShape` | Who wrote a row, when, from what evidence (`grounding`, at least one), and its `revision`: `pending`, `revised` or `affirmed`. A revised or affirmed row names who and when. |
+| `StatementStatus` | `clear`, `unclear`, `undefinable`, `needs-resolution`. A clear or unclear row carries its statement. |
+| `STATEMENT_WORD_LIMIT`, `countWords`, `checkStatement`, `StatementSchema` | The 55-word limit. A writer over it records `needs-resolution` without a statement and moves on. |
+| `capabilityClaims`, `findSharedCapabilities` | Which capabilities two or more providers give: a relation to name, not a conflict. |
+
+Schemas are strict: in rows written by models, an unknown key is far more often a
+misspelling than a new field.
+
+Zero I/O, zero persistence, zero clock.
+
+## Used by
+
+`@medicine-wheel/developer-repository-mapping`: a feature `realizes` a capability, a
+repository `provides` one, and every mapping row carries this package's attribution.
+
+Spec: [`rispecs/developer-suite/repository-mapping/capabilities.spec.md`](https://github.com/jgwill/medicine-wheel/blob/main/rispecs/developer-suite/repository-mapping/capabilities.spec.md).

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @medicine-wheel/capabilities
+ *
+ * The platform-features and capabilities layer of the Medicine Wheel Developer
+ * Suite: what the platform can do for someone, which repositories and services
+ * give it, and who said so. A sibling of `@medicine-wheel/infra`, built the
+ * same way: a `metadata.kind` discriminator in `ontology-core`
+ * (`DEVELOPER_ENTITY_BINDING`), typed facets keyed by node id, Zod schemas at
+ * the boundary, pure functions.
+ *
+ * `@medicine-wheel/developer-repository-mapping` consumes it: a feature
+ * observed in a repository `realizes` a capability, and a repository
+ * `provides` one.
+ *
+ * Zero I/O, zero persistence, zero clock.
+ *
+ * @packageDocumentation
+ */
+export type { NodeId, StatementStatus, RevisionState, Attribution, CapabilityFacet, CapabilityClaim, SharedCapability, } from './types';
+export { STATEMENT_WORD_LIMIT } from './types';
+export { countWords, checkStatement, isSlug, capabilityNodeId } from './statement';
+export type { StatementCheck } from './statement';
+export { StatementStatusSchema, RevisionStateSchema, TimestampSchema, StatementSchema, attributionShape, refineAttribution, refineStatementPresence, CapabilityNodeIdSchema, CapabilityFacetSchema, } from './schemas';
+export type { ValidatedCapabilityFacet } from './schemas';
+export { capabilityClaims, findSharedCapabilities } from './shared';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,YAAY,EACV,MAAM,EACN,eAAe,EACf,aAAa,EACb,WAAW,EACX,eAAe,EACf,eAAe,EACf,gBAAgB,GACjB,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAG/C,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACnF,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAGlD,OAAO,EACL,qBAAqB,EACrB,mBAAmB,EACnB,eAAe,EACf,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,uBAAuB,EACvB,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,WAAW,CAAC;AAEnB,YAAY,EAAE,wBAAwB,EAAE,MAAM,WAAW,CAAC;AAG1D,OAAO,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC"}

package/dist/index.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * @medicine-wheel/capabilities
+ *
+ * The platform-features and capabilities layer of the Medicine Wheel Developer
+ * Suite: what the platform can do for someone, which repositories and services
+ * give it, and who said so. A sibling of `@medicine-wheel/infra`, built the
+ * same way: a `metadata.kind` discriminator in `ontology-core`
+ * (`DEVELOPER_ENTITY_BINDING`), typed facets keyed by node id, Zod schemas at
+ * the boundary, pure functions.
+ *
+ * `@medicine-wheel/developer-repository-mapping` consumes it: a feature
+ * observed in a repository `realizes` a capability, and a repository
+ * `provides` one.
+ *
+ * Zero I/O, zero persistence, zero clock.
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findSharedCapabilities = exports.capabilityClaims = exports.CapabilityFacetSchema = exports.CapabilityNodeIdSchema = exports.refineStatementPresence = exports.refineAttribution = exports.attributionShape = exports.StatementSchema = exports.TimestampSchema = exports.RevisionStateSchema = exports.StatementStatusSchema = exports.capabilityNodeId = exports.isSlug = exports.checkStatement = exports.countWords = exports.STATEMENT_WORD_LIMIT = void 0;
+var types_1 = require("./types");
+Object.defineProperty(exports, "STATEMENT_WORD_LIMIT", { enumerable: true, get: function () { return types_1.STATEMENT_WORD_LIMIT; } });
+// ── The word limit ──────────────────────────────────────────────────────────
+var statement_1 = require("./statement");
+Object.defineProperty(exports, "countWords", { enumerable: true, get: function () { return statement_1.countWords; } });
+Object.defineProperty(exports, "checkStatement", { enumerable: true, get: function () { return statement_1.checkStatement; } });
+Object.defineProperty(exports, "isSlug", { enumerable: true, get: function () { return statement_1.isSlug; } });
+Object.defineProperty(exports, "capabilityNodeId", { enumerable: true, get: function () { return statement_1.capabilityNodeId; } });
+// ── Zod schemas ─────────────────────────────────────────────────────────────
+var schemas_1 = require("./schemas");
+Object.defineProperty(exports, "StatementStatusSchema", { enumerable: true, get: function () { return schemas_1.StatementStatusSchema; } });
+Object.defineProperty(exports, "RevisionStateSchema", { enumerable: true, get: function () { return schemas_1.RevisionStateSchema; } });
+Object.defineProperty(exports, "TimestampSchema", { enumerable: true, get: function () { return schemas_1.TimestampSchema; } });
+Object.defineProperty(exports, "StatementSchema", { enumerable: true, get: function () { return schemas_1.StatementSchema; } });
+Object.defineProperty(exports, "attributionShape", { enumerable: true, get: function () { return schemas_1.attributionShape; } });
+Object.defineProperty(exports, "refineAttribution", { enumerable: true, get: function () { return schemas_1.refineAttribution; } });
+Object.defineProperty(exports, "refineStatementPresence", { enumerable: true, get: function () { return schemas_1.refineStatementPresence; } });
+Object.defineProperty(exports, "CapabilityNodeIdSchema", { enumerable: true, get: function () { return schemas_1.CapabilityNodeIdSchema; } });
+Object.defineProperty(exports, "CapabilityFacetSchema", { enumerable: true, get: function () { return schemas_1.CapabilityFacetSchema; } });
+// ── Shared capabilities ─────────────────────────────────────────────────────
+var shared_1 = require("./shared");
+Object.defineProperty(exports, "capabilityClaims", { enumerable: true, get: function () { return shared_1.capabilityClaims; } });
+Object.defineProperty(exports, "findSharedCapabilities", { enumerable: true, get: function () { return shared_1.findSharedCapabilities; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;GAiBG;;;AAaH,iCAA+C;AAAtC,6GAAA,oBAAoB,OAAA;AAE7B,+EAA+E;AAC/E,yCAAmF;AAA1E,uGAAA,UAAU,OAAA;AAAE,2GAAA,cAAc,OAAA;AAAE,mGAAA,MAAM,OAAA;AAAE,6GAAA,gBAAgB,OAAA;AAG7D,+EAA+E;AAC/E,qCAUmB;AATjB,gHAAA,qBAAqB,OAAA;AACrB,8GAAA,mBAAmB,OAAA;AACnB,0GAAA,eAAe,OAAA;AACf,0GAAA,eAAe,OAAA;AACf,2GAAA,gBAAgB,OAAA;AAChB,4GAAA,iBAAiB,OAAA;AACjB,kHAAA,uBAAuB,OAAA;AACvB,iHAAA,sBAAsB,OAAA;AACtB,gHAAA,qBAAqB,OAAA;AAKvB,+EAA+E;AAC/E,mCAAoE;AAA3D,0GAAA,gBAAgB,OAAA;AAAE,gHAAA,sBAAsB,OAAA"}

package/dist/schemas.d.ts

@@ -0,0 +1,137 @@
+/**
+ * Zod schemas for capability rows and for the attribution every row carries.
+ *
+ * These exist for the boundary where a model's reading of a repository becomes
+ * a row someone else will trust. The parse is where an over-long statement, a
+ * row with no evidence, or an `affirmed` row that names no person gets caught.
+ * Objects are strict: in a dataset written by models, an unknown key is far
+ * more often a misspelling than a new field.
+ */
+import { z } from 'zod';
+export declare const StatementStatusSchema: z.ZodEnum<["clear", "unclear", "undefinable", "needs-resolution"]>;
+export declare const RevisionStateSchema: z.ZodEnum<["pending", "revised", "affirmed"]>;
+/** ISO 8601 with a zone: '2026-10-18T21:56:00Z', or git's '2026-10-14T22:28:46-04:00'. */
+export declare const TimestampSchema: z.ZodString;
+/** A statement of at least one word and at most {@link STATEMENT_WORD_LIMIT}. */
+export declare const StatementSchema: z.ZodEffects<z.ZodString, string, string>;
+/** The attribution fields, as a shape other row schemas spread into their own. */
+export declare const attributionShape: {
+    statedBy: z.ZodString;
+    statedAt: z.ZodString;
+    grounding: z.ZodArray<z.ZodString, "many">;
+    revision: z.ZodEnum<["pending", "revised", "affirmed"]>;
+    revisedBy: z.ZodOptional<z.ZodString>;
+    revisedAt: z.ZodOptional<z.ZodString>;
+};
+/** A `revised` or `affirmed` row names who revised it and when. */
+export declare function refineAttribution(row: {
+    revision: string;
+    revisedBy?: string;
+    revisedAt?: string;
+}, ctx: z.RefinementCtx): void;
+/** A `clear` or `unclear` row carries its statement; the other two may not have one. */
+export declare function refineStatementPresence(status: string, statement: string | undefined, field: string, ctx: z.RefinementCtx): void;
+export declare const CapabilityNodeIdSchema: z.ZodString;
+export declare const CapabilityFacetSchema: z.ZodEffects<z.ZodObject<{
+    statedBy: z.ZodString;
+    statedAt: z.ZodString;
+    grounding: z.ZodArray<z.ZodString, "many">;
+    revision: z.ZodEnum<["pending", "revised", "affirmed"]>;
+    revisedBy: z.ZodOptional<z.ZodString>;
+    revisedAt: z.ZodOptional<z.ZodString>;
+    nodeId: z.ZodString;
+    name: z.ZodString;
+    statement: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    status: z.ZodEnum<["clear", "unclear", "undefinable", "needs-resolution"]>;
+    providedBy: z.ZodArray<z.ZodString, "many">;
+    metis: z.ZodOptional<z.ZodObject<{
+        exceptions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        invisibleWork: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        notes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        heldBy: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        exceptions?: string[] | undefined;
+        invisibleWork?: string[] | undefined;
+        notes?: string[] | undefined;
+        heldBy?: string | undefined;
+    }, {
+        exceptions?: string[] | undefined;
+        invisibleWork?: string[] | undefined;
+        notes?: string[] | undefined;
+        heldBy?: string | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    status: "clear" | "unclear" | "undefinable" | "needs-resolution";
+    nodeId: string;
+    name: string;
+    providedBy: string[];
+    statedBy: string;
+    statedAt: string;
+    grounding: string[];
+    revision: "pending" | "revised" | "affirmed";
+    revisedBy?: string | undefined;
+    revisedAt?: string | undefined;
+    statement?: string | undefined;
+    metis?: {
+        exceptions?: string[] | undefined;
+        invisibleWork?: string[] | undefined;
+        notes?: string[] | undefined;
+        heldBy?: string | undefined;
+    } | undefined;
+}, {
+    status: "clear" | "unclear" | "undefinable" | "needs-resolution";
+    nodeId: string;
+    name: string;
+    providedBy: string[];
+    statedBy: string;
+    statedAt: string;
+    grounding: string[];
+    revision: "pending" | "revised" | "affirmed";
+    revisedBy?: string | undefined;
+    revisedAt?: string | undefined;
+    statement?: string | undefined;
+    metis?: {
+        exceptions?: string[] | undefined;
+        invisibleWork?: string[] | undefined;
+        notes?: string[] | undefined;
+        heldBy?: string | undefined;
+    } | undefined;
+}>, {
+    status: "clear" | "unclear" | "undefinable" | "needs-resolution";
+    nodeId: string;
+    name: string;
+    providedBy: string[];
+    statedBy: string;
+    statedAt: string;
+    grounding: string[];
+    revision: "pending" | "revised" | "affirmed";
+    revisedBy?: string | undefined;
+    revisedAt?: string | undefined;
+    statement?: string | undefined;
+    metis?: {
+        exceptions?: string[] | undefined;
+        invisibleWork?: string[] | undefined;
+        notes?: string[] | undefined;
+        heldBy?: string | undefined;
+    } | undefined;
+}, {
+    status: "clear" | "unclear" | "undefinable" | "needs-resolution";
+    nodeId: string;
+    name: string;
+    providedBy: string[];
+    statedBy: string;
+    statedAt: string;
+    grounding: string[];
+    revision: "pending" | "revised" | "affirmed";
+    revisedBy?: string | undefined;
+    revisedAt?: string | undefined;
+    statement?: string | undefined;
+    metis?: {
+        exceptions?: string[] | undefined;
+        invisibleWork?: string[] | undefined;
+        notes?: string[] | undefined;
+        heldBy?: string | undefined;
+    } | undefined;
+}>;
+export type ValidatedCapabilityFacet = z.infer<typeof CapabilityFacetSchema>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,qBAAqB,oEAAkE,CAAC;AAErG,eAAO,MAAM,mBAAmB,+CAA6C,CAAC;AAE9E,0FAA0F;AAC1F,eAAO,MAAM,eAAe,aAAwC,CAAC;AAErE,iFAAiF;AACjF,eAAO,MAAM,eAAe,2CAU1B,CAAC;AAEH,kFAAkF;AAClF,eAAO,MAAM,gBAAgB;;;;;;;CAO5B,CAAC;AAEF,mEAAmE;AACnE,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,EACjE,GAAG,EAAE,CAAC,CAAC,aAAa,GACnB,IAAI,CAQN;AAED,wFAAwF;AACxF,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,CAAC,CAAC,aAAa,GACnB,IAAI,CAIN;AAED,eAAO,MAAM,sBAAsB,aAEiE,CAAC;AAErG,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAc9B,CAAC;AAGL,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/schemas.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * Zod schemas for capability rows and for the attribution every row carries.
+ *
+ * These exist for the boundary where a model's reading of a repository becomes
+ * a row someone else will trust. The parse is where an over-long statement, a
+ * row with no evidence, or an `affirmed` row that names no person gets caught.
+ * Objects are strict: in a dataset written by models, an unknown key is far
+ * more often a misspelling than a new field.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CapabilityFacetSchema = exports.CapabilityNodeIdSchema = exports.attributionShape = exports.StatementSchema = exports.TimestampSchema = exports.RevisionStateSchema = exports.StatementStatusSchema = void 0;
+exports.refineAttribution = refineAttribution;
+exports.refineStatementPresence = refineStatementPresence;
+const zod_1 = require("zod");
+const infra_1 = require("@medicine-wheel/infra");
+const statement_1 = require("./statement");
+const types_1 = require("./types");
+exports.StatementStatusSchema = zod_1.z.enum(['clear', 'unclear', 'undefinable', 'needs-resolution']);
+exports.RevisionStateSchema = zod_1.z.enum(['pending', 'revised', 'affirmed']);
+/** ISO 8601 with a zone: '2026-10-18T21:56:00Z', or git's '2026-10-14T22:28:46-04:00'. */
+exports.TimestampSchema = zod_1.z.string().datetime({ offset: true });
+/** A statement of at least one word and at most {@link STATEMENT_WORD_LIMIT}. */
+exports.StatementSchema = zod_1.z.string().superRefine((text, ctx) => {
+    const { words, fits } = (0, statement_1.checkStatement)(text);
+    if (fits)
+        return;
+    ctx.addIssue({
+        code: zod_1.z.ZodIssueCode.custom,
+        message: words === 0
+            ? 'a statement needs at least one word'
+            : `${words} words, the limit is ${types_1.STATEMENT_WORD_LIMIT}: record the row as needs-resolution without a statement and move to the next one`,
+    });
+});
+/** The attribution fields, as a shape other row schemas spread into their own. */
+exports.attributionShape = {
+    statedBy: zod_1.z.string().min(1),
+    statedAt: exports.TimestampSchema,
+    grounding: zod_1.z.array(zod_1.z.string().min(1)).min(1),
+    revision: exports.RevisionStateSchema,
+    revisedBy: zod_1.z.string().min(1).optional(),
+    revisedAt: exports.TimestampSchema.optional(),
+};
+/** A `revised` or `affirmed` row names who revised it and when. */
+function refineAttribution(row, ctx) {
+    if (row.revision === 'pending')
+        return;
+    if (!row.revisedBy) {
+        ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, path: ['revisedBy'], message: `a ${row.revision} row names who revised it` });
+    }
+    if (!row.revisedAt) {
+        ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, path: ['revisedAt'], message: `a ${row.revision} row says when it was revised` });
+    }
+}
+/** A `clear` or `unclear` row carries its statement; the other two may not have one. */
+function refineStatementPresence(status, statement, field, ctx) {
+    if ((status === 'clear' || status === 'unclear') && !statement) {
+        ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, path: [field], message: `a ${status} row carries its ${field}` });
+    }
+}
+exports.CapabilityNodeIdSchema = zod_1.z
+    .string()
+    .regex(/^capability:[a-z0-9]+(?:-[a-z0-9]+)*$/, 'a capability id is capability:<kebab-case-slug>');
+exports.CapabilityFacetSchema = zod_1.z
+    .object({
+    nodeId: exports.CapabilityNodeIdSchema,
+    name: zod_1.z.string().min(1),
+    statement: exports.StatementSchema.optional(),
+    status: exports.StatementStatusSchema,
+    providedBy: zod_1.z.array(zod_1.z.string().min(1)),
+    metis: infra_1.MetisHoldSchema.optional(),
+    ...exports.attributionShape,
+})
+    .strict()
+    .superRefine((row, ctx) => {
+    refineAttribution(row, ctx);
+    refineStatementPresence(row.status, row.statement, 'statement', ctx);
+});
+//# sourceMappingURL=schemas.js.map

package/dist/schemas.js.map

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

package/dist/shared.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Which capabilities more than one provider offers.
+ *
+ * The counterpart of `infra`'s `detectPortConflicts`, with the opposite
+ * reading. Two services cannot both hold a port; two repositories can both
+ * give a capability, and when they do there is a relation to name between
+ * them — a prototype and the implementation that grew from it, or one intent
+ * explored twice by different hands.
+ */
+import type { CapabilityClaim, CapabilityFacet, SharedCapability } from './types';
+/** The claims a set of capabilities make through their own `providedBy`. */
+export declare function capabilityClaims(capabilities: readonly CapabilityFacet[]): CapabilityClaim[];
+/**
+ * Every capability claimed by two or more distinct providers, sorted by
+ * capability id, providers distinct and sorted. A provider claiming the same
+ * capability twice (through two of its features, say) counts once.
+ */
+export declare function findSharedCapabilities(claims: readonly CapabilityClaim[]): SharedCapability[];
+//# sourceMappingURL=shared.d.ts.map

package/dist/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../src/shared.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAElF,4EAA4E;AAC5E,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,SAAS,eAAe,EAAE,GAAG,eAAe,EAAE,CAE5F;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,SAAS,eAAe,EAAE,GAAG,gBAAgB,EAAE,CAW7F"}

package/dist/shared.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Which capabilities more than one provider offers.
+ *
+ * The counterpart of `infra`'s `detectPortConflicts`, with the opposite
+ * reading. Two services cannot both hold a port; two repositories can both
+ * give a capability, and when they do there is a relation to name between
+ * them — a prototype and the implementation that grew from it, or one intent
+ * explored twice by different hands.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capabilityClaims = capabilityClaims;
+exports.findSharedCapabilities = findSharedCapabilities;
+/** The claims a set of capabilities make through their own `providedBy`. */
+function capabilityClaims(capabilities) {
+    return capabilities.flatMap((c) => c.providedBy.map((provider) => ({ capability: c.nodeId, provider })));
+}
+/**
+ * Every capability claimed by two or more distinct providers, sorted by
+ * capability id, providers distinct and sorted. A provider claiming the same
+ * capability twice (through two of its features, say) counts once.
+ */
+function findSharedCapabilities(claims) {
+    const providers = new Map();
+    for (const claim of claims) {
+        let set = providers.get(claim.capability);
+        if (!set)
+            providers.set(claim.capability, (set = new Set()));
+        set.add(claim.provider);
+    }
+    return [...providers.entries()]
+        .filter(([, set]) => set.size > 1)
+        .map(([capability, set]) => ({ capability, providers: [...set].sort() }))
+        .sort((a, b) => (a.capability < b.capability ? -1 : a.capability > b.capability ? 1 : 0));
+}
+//# sourceMappingURL=shared.js.map

package/dist/shared.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.js","sourceRoot":"","sources":["../src/shared.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;AAKH,4CAEC;AAOD,wDAWC;AArBD,4EAA4E;AAC5E,SAAgB,gBAAgB,CAAC,YAAwC;IACvE,OAAO,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC;AAC3G,CAAC;AAED;;;;GAIG;AACH,SAAgB,sBAAsB,CAAC,MAAkC;IACvE,MAAM,SAAS,GAAG,IAAI,GAAG,EAAuB,CAAC;IACjD,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,IAAI,GAAG,GAAG,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QAC1C,IAAI,CAAC,GAAG;YAAE,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC,GAAG,GAAG,IAAI,GAAG,EAAE,CAAC,CAAC,CAAC;QAC7D,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IAC1B,CAAC;IACD,OAAO,CAAC,GAAG,SAAS,CAAC,OAAO,EAAE,CAAC;SAC5B,MAAM,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC;SACjC,GAAG,CAAC,CAAC,CAAC,UAAU,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;SACxE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,UAAU,GAAG,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,GAAG,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAC9F,CAAC"}

package/dist/statement.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The word limit, as a function a writer can ask before it writes.
+ *
+ * A writer that cannot say what a thing is in 55 words stops there, records
+ * the row as `needs-resolution` without a statement, and moves to the next
+ * thing. The limit is what keeps a mapping of a hundred repositories readable
+ * by a person, and what keeps a model from describing more than it read.
+ */
+/** A word is a whitespace-separated token holding at least one letter or digit. */
+export declare function countWords(text: string): number;
+export interface StatementCheck {
+    words: number;
+    limit: number;
+    /** `true` when the statement has at least one word and no more than `limit`. */
+    fits: boolean;
+}
+export declare function checkStatement(text: string, limit?: number): StatementCheck;
+/** True for a kebab-case slug: 'publish-prototype-to-episode'. */
+export declare function isSlug(value: string): boolean;
+/** `capability:<slug>`. Throws on a slug that is not kebab-case. */
+export declare function capabilityNodeId(slug: string): string;
+//# sourceMappingURL=statement.d.ts.map

package/dist/statement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statement.d.ts","sourceRoot":"","sources":["../src/statement.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,mFAAmF;AACnF,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAI/C;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,gFAAgF;IAChF,IAAI,EAAE,OAAO,CAAC;CACf;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,GAAE,MAA6B,GAAG,cAAc,CAGjG;AAID,kEAAkE;AAClE,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAE7C;AAED,oEAAoE;AACpE,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGrD"}

package/dist/statement.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * The word limit, as a function a writer can ask before it writes.
+ *
+ * A writer that cannot say what a thing is in 55 words stops there, records
+ * the row as `needs-resolution` without a statement, and moves to the next
+ * thing. The limit is what keeps a mapping of a hundred repositories readable
+ * by a person, and what keeps a model from describing more than it read.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countWords = countWords;
+exports.checkStatement = checkStatement;
+exports.isSlug = isSlug;
+exports.capabilityNodeId = capabilityNodeId;
+const types_1 = require("./types");
+/** A word is a whitespace-separated token holding at least one letter or digit. */
+function countWords(text) {
+    return text
+        .split(/\s+/u)
+        .filter((token) => /[\p{L}\p{N}]/u.test(token)).length;
+}
+function checkStatement(text, limit = types_1.STATEMENT_WORD_LIMIT) {
+    const words = countWords(text);
+    return { words, limit, fits: words > 0 && words <= limit };
+}
+const SLUG = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+/** True for a kebab-case slug: 'publish-prototype-to-episode'. */
+function isSlug(value) {
+    return SLUG.test(value);
+}
+/** `capability:<slug>`. Throws on a slug that is not kebab-case. */
+function capabilityNodeId(slug) {
+    if (!isSlug(slug))
+        throw new Error(`not a kebab-case slug: ${JSON.stringify(slug)}`);
+    return `capability:${slug}`;
+}
+//# sourceMappingURL=statement.js.map

package/dist/statement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"statement.js","sourceRoot":"","sources":["../src/statement.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;AAKH,gCAIC;AASD,wCAGC;AAKD,wBAEC;AAGD,4CAGC;AAhCD,mCAA+C;AAE/C,mFAAmF;AACnF,SAAgB,UAAU,CAAC,IAAY;IACrC,OAAO,IAAI;SACR,KAAK,CAAC,MAAM,CAAC;SACb,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC;AAC3D,CAAC;AASD,SAAgB,cAAc,CAAC,IAAY,EAAE,QAAgB,4BAAoB;IAC/E,MAAM,KAAK,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;IAC/B,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,GAAG,CAAC,IAAI,KAAK,IAAI,KAAK,EAAE,CAAC;AAC7D,CAAC;AAED,MAAM,IAAI,GAAG,4BAA4B,CAAC;AAE1C,kEAAkE;AAClE,SAAgB,MAAM,CAAC,KAAa;IAClC,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAC1B,CAAC;AAED,oEAAoE;AACpE,SAAgB,gBAAgB,CAAC,IAAY;IAC3C,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,0BAA0B,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACrF,OAAO,cAAc,IAAI,EAAE,CAAC;AAC9B,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Facet types for @medicine-wheel/capabilities.
+ *
+ * A capability is something the platform can do for someone — publish a
+ * prototype to an episode, register a service, follow a wheel's events. It
+ * rides a `knowledge` node carrying `metadata.kind: 'capability'`
+ * (`DEVELOPER_ENTITY_BINDING` in `ontology-core`), and this facet holds its
+ * specifics keyed by node id, the way `@medicine-wheel/infra` holds a
+ * service's.
+ *
+ * Every statement here was written by someone at some time, and most of them
+ * will be written by a model reading repositories. A model's reading is
+ * assumed biased until a person has read it, so every row says who wrote it,
+ * when, what it read, and whether anyone has revised it since.
+ */
+import type { RelationalNode } from '@medicine-wheel/ontology-core';
+import type { MetisHold } from '@medicine-wheel/infra';
+/** The id of the `RelationalNode` a facet annotates. */
+export type NodeId = RelationalNode['id'];
+/**
+ * Whether a statement says what a thing is, in words a reader can act on.
+ *
+ * - `clear` — the statement fits the word limit and the evidence read supports it.
+ * - `unclear` — a statement exists, but the evidence read does not settle it
+ *   (a README that contradicts the code, a name that promises more than is there).
+ * - `undefinable` — what is there cannot be stated as one thing: an empty fork,
+ *   a scratch folder, a snapshot of someone else's work.
+ * - `needs-resolution` — a statement was attempted and did not fit the limit,
+ *   or two sources disagree and a person has to settle which one holds.
+ */
+export type StatementStatus = 'clear' | 'unclear' | 'undefinable' | 'needs-resolution';
+/**
+ * Where a row stands with the people it describes.
+ *
+ * - `pending` — written, nobody has read it since. Every row a model writes starts here.
+ * - `revised` — a later reading corrected it.
+ * - `affirmed` — a person read it and stands behind it.
+ */
+export type RevisionState = 'pending' | 'revised' | 'affirmed';
+/**
+ * Who wrote a row, when, from what, and who has read it since. Required on
+ * every row: a statement with no author and no time is a rumour, the rule
+ * `infra`'s `ObservedState` keeps for machine readings.
+ */
+export interface Attribution {
+    /** A model id ('claude-opus-5-5'), an agent seat or a person. */
+    statedBy: string;
+    /** ISO 8601. */
+    statedAt: string;
+    /** What was read: file paths, commits, URLs, owner/repo#n. At least one. */
+    grounding: string[];
+    revision: RevisionState;
+    /** Required once `revision` is `revised` or `affirmed`. */
+    revisedBy?: string;
+    /** Required once `revision` is `revised` or `affirmed`. */
+    revisedAt?: string;
+}
+/** A platform capability. Annotates a `RelationalNode` of type `'knowledge'`. */
+export interface CapabilityFacet extends Attribution {
+    /** → `RelationalNode.id`, `capability:<slug>` */
+    nodeId: NodeId;
+    /** 'Publish a prototype to an episode' */
+    name: string;
+    /** At most {@link STATEMENT_WORD_LIMIT} words. Required when `status` is `clear` or `unclear`. */
+    statement?: string;
+    status: StatementStatus;
+    /** Repository or service node ids that offer it. */
+    providedBy: NodeId[];
+    metis?: MetisHold;
+}
+/**
+ * One provider's claim on a capability. It comes from a capability's own
+ * `providedBy`, or from a feature that realizes it (`via` names the feature).
+ */
+export interface CapabilityClaim {
+    /** → `CapabilityFacet.nodeId` */
+    capability: NodeId;
+    /** A repository or service node id. */
+    provider: NodeId;
+    /** The feature the claim comes from, when it comes from one. */
+    via?: NodeId;
+}
+/**
+ * A capability that more than one provider offers. Not a conflict: two
+ * repositories giving the same capability are kin to name — one may have
+ * grown from the other, or both may be the same intent explored twice.
+ */
+export interface SharedCapability {
+    /** → `CapabilityFacet.nodeId` */
+    capability: NodeId;
+    /** Distinct, sorted, at least two. */
+    providers: NodeId[];
+}
+/** The word limit for every statement: a capability, a feature, a repository's purpose. */
+export declare const STATEMENT_WORD_LIMIT = 55;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AACpE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAEvD,wDAAwD;AACxD,MAAM,MAAM,MAAM,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC;AAE1C;;;;;;;;;;GAUG;AACH,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,SAAS,GAAG,aAAa,GAAG,kBAAkB,CAAC;AAEvF;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,SAAS,GAAG,UAAU,CAAC;AAE/D;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,iEAAiE;IACjE,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,4EAA4E;IAC5E,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,QAAQ,EAAE,aAAa,CAAC;IACxB,2DAA2D;IAC3D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,2DAA2D;IAC3D,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,iFAAiF;AACjF,MAAM,WAAW,eAAgB,SAAQ,WAAW;IAClD,iDAAiD;IACjD,MAAM,EAAE,MAAM,CAAC;IACf,0CAA0C;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,kGAAkG;IAClG,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,eAAe,CAAC;IACxB,oDAAoD;IACpD,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,KAAK,CAAC,EAAE,SAAS,CAAC;CACnB;AAED;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,iCAAiC;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,uCAAuC;IACvC,QAAQ,EAAE,MAAM,CAAC;IACjB,gEAAgE;IAChE,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,iCAAiC;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,sCAAsC;IACtC,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED,2FAA2F;AAC3F,eAAO,MAAM,oBAAoB,KAAK,CAAC"}

package/dist/types.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Facet types for @medicine-wheel/capabilities.
+ *
+ * A capability is something the platform can do for someone — publish a
+ * prototype to an episode, register a service, follow a wheel's events. It
+ * rides a `knowledge` node carrying `metadata.kind: 'capability'`
+ * (`DEVELOPER_ENTITY_BINDING` in `ontology-core`), and this facet holds its
+ * specifics keyed by node id, the way `@medicine-wheel/infra` holds a
+ * service's.
+ *
+ * Every statement here was written by someone at some time, and most of them
+ * will be written by a model reading repositories. A model's reading is
+ * assumed biased until a person has read it, so every row says who wrote it,
+ * when, what it read, and whether anyone has revised it since.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STATEMENT_WORD_LIMIT = void 0;
+/** The word limit for every statement: a capability, a feature, a repository's purpose. */
+exports.STATEMENT_WORD_LIMIT = 55;
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAwFH,2FAA2F;AAC9E,QAAA,oBAAoB,GAAG,EAAE,CAAC"}

package/package.json

@@ -1,6 +1,51 @@
 {
   "name": "@medicine-wheel/capabilities",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.21.0",
+  "description": "The platform-features and capabilities layer of the Medicine Wheel Developer Suite — what the platform can do, which repositories and services provide it, who said so and from what, with the 55-word statement limit and shared-capability detection",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "lint": "tsc --noEmit",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run clean && npm run build"
+  },
+  "keywords": [
+    "medicine-wheel",
+    "capabilities",
+    "platform-features",
+    "developer-suite",
+    "relational-ontology",
+    "inventory"
+  ],
+  "author": "IAIP Collaborative - Shawinigan, QC",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jgwill/medicine-wheel.git",
+    "directory": "src/capabilities"
+  },
+  "dependencies": {
+    "@medicine-wheel/infra": "^0.21.0",
+    "@medicine-wheel/ontology-core": "^0.21.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "typescript": "^5.3.0"
+  }
+}