@phis/contracts 0.7.2 → 0.7.4

package/README.md

@@ -22,6 +22,7 @@ and change at different moments.
 @phis/contracts/http                 the request headers phis and the site UI must spell the same way
 @phis/contracts/locale               the locale this software is authored in
 @phis/contracts/logging              the structured log vocabulary a Site writes and phis reads back
+@phis/contracts/search               the documents a Site writes of its Pages and the hits phis answers a query with
 @phis/contracts/server-capabilities  the capability snapshot phis reports and the UI acts on
 @phis/contracts/site-groups          the membership levels of a Site group, as both ends count them
 @phis/contracts/user-state           the shapes a Module may keep a person's decisions in, and the key grammar
@@ -60,7 +61,14 @@ erased at compile time apart from a handful of constants.
 What it covers:
 
 - **Manifest** -- `PhisAddonManifestV1`: identity, version, required Core capabilities, the routes an
-  Add-on claims, the services it provides.
+  Add-on claims, the services it provides, the jobs it runs and the events it listens to or emits.
+- **Jobs and events** -- a job carries a `PhisAddonJobSchedule` (`every` one of
+  `PHIS_ADDON_JOB_INTERVALS`, five minutes at the shortest, with `at` and `weekday` for the daily and
+  weekly steps) that Core keeps: each moment of a schedule is run by exactly one instance. An event an
+  Add-on emits is a `PhisAddonEmittedEventId`, its own id in front (`@scope/name:what.happened`),
+  declared under `emits` and sent through the `events` capability (`PhisEventsCapabilityV1`); a listener
+  receives a `PhisAddonEmittedEventSubject` with emitter, time, hop count, dedupe key and facts. Core's
+  own events keep their bare names. `PHIS_ADDON_EVENT_MAX_HOPS` bounds a chain of handlers emitting.
 - **Runtime** -- `PhisAddonRuntimeV1`, `PhisAddonHandler`, `PhisAddonRequestContext`. The artifact
   exports it under the name `phisAddon` (`PhisAddonRuntimeModuleV1`).
 - **Schema** -- `PhisAddonSchemaDescriptor` and its column, index and constraint descriptors. Tables are
@@ -190,6 +198,18 @@ The structured log vocabulary: `PhiLogService` (`phis`, `ui`, `site`, `cli`), `P
 to journald, and the log surface in phis parses them back, filtering by exactly these services and
 fields. How a line is serialised is each writer's own concern.
 
+## `/search`
+
+Searching a Site's own Pages, split the only way it can be: the Site writes the documents, phis keeps and
+searches them. A Page's words stand in Widget configs, in content phis stores without knowing which Page
+shows it, and in documents fetched while the Page is drawn, so only the Site -- resolving a Page as a
+visitor's request does -- sees the whole text. It sends one `PhiSearchIndexSet` per Area and language,
+named by a `fingerprint` of what it was built from, so a set phis already holds is not written twice;
+phis answers a query with `PhiSearchResponse`, each `PhiSearchHit` carrying its Page's path and a
+snippet in pieces. `readPhiSearchQuery` and `tokenizePhiSearchQuery` are called on both ends, so a
+query the Site calls too short is one phis would not have answered. Only the Public and App Areas are
+indexed (`PHI_SEARCH_INDEXED_AREA_MASK`).
+
 ## `/server-capabilities`
 
 The snapshot `/api/v1/site/capabilities` reports: per provider (Core or an Add-on), the capabilities it

package/dist/addon.d.ts

@@ -12,7 +12,7 @@
  * back a constant, it is in the wrong package.
  */
 import type { PhisAddonCapabilities, PhisAddonEventHandler, PhisAddonJobHandler, PhisSiteAccess } from "./capabilities.js";
-import type { PhisAddonEventId, PhisCoreCapabilityId, PhisServiceKind } from "./core.js";
+import type { PhisAddonEmittedEventId, PhisAddonEventId, PhisCoreCapabilityId, PhisServiceKind } from "./core.js";
 import type { PhisAddonQueryCatalog } from "./queries.js";
 import type { PhisAddonSchemaDescriptor } from "./schema.js";
 export declare const PHIS_ADDON_MANIFEST_VERSION: 1;
@@ -101,17 +101,61 @@ export type PhisAddonServiceProviderDescriptor = {
     factoryExport: string;
     requiredCoreCapabilities: PhisCoreCapabilityId[];
 };
+/**
+ * The steps a job may run at. Every step divides the hour or the day, so the moments a schedule names
+ * fall on the clock -- `5m` is :00, :05, :10 -- and every instance of Core computes the same moment
+ * from the same clock without asking another.
+ *
+ * Nothing shorter than five minutes: a job that has to look more often than that is polling for an
+ * event, and an event is what it should be given. Jobs run per Site, so a short step multiplies by
+ * the Sites of a stage, and the services a job reads from have quotas of their own.
+ */
+export declare const PHIS_ADDON_JOB_INTERVALS: readonly ["5m", "15m", "30m", "hourly", "daily", "weekly"];
+export type PhisAddonJobInterval = (typeof PHIS_ADDON_JOB_INTERVALS)[number];
+/**
+ * When a job wants to run. Core keeps it: the schedule is a promise, not a note for the operator.
+ *
+ * A schedule is a series of moments, and each moment is claimed by exactly one instance of Core --
+ * the claim is a row whose key is the moment, so the database, not a leader, decides who runs. A
+ * moment nobody claimed while every instance was down is run once at the next start, the latest one
+ * only; a job does not receive a week of missed runs after a week of downtime. A job still running
+ * when its next moment comes has that moment recorded as skipped rather than run beside itself, which
+ * is why a handler must finish well inside its own step.
+ */
+export type PhisAddonJobSchedule = {
+    every: PhisAddonJobInterval;
+    /**
+     * The time of day, `HH:MM` in UTC, for `daily` and `weekly`; absent means `00:00`. Not for the shorter
+     * steps, which fall on the clock by themselves.
+     */
+    at?: string;
+    /** The ISO weekday for `weekly`, 1 (Monday) to 7 (Sunday); absent means Monday. */
+    weekday?: number;
+};
 export type PhisAddonJobDescriptor = {
     id: string;
     handler: string;
     /**
-     * How often this job expects to run, for the operator to read -- never a schedule Core keeps.
+     * When Core runs this job. Absent means it runs only when an operator starts it with `phis addon
+     * job`, which also runs a scheduled job out of turn.
      *
-     * phi-server serves from several instances, so an in-process timer would fire once per instance for
-     * one intended run. The operator schedules `phis addon job run`, which is one runner by construction,
-     * and this field tells them what the Add-on had in mind.
+     * Optional like every field added after this manifest version was in the wild.
      */
-    suggestedInterval?: "hourly" | "daily" | "weekly";
+    schedule?: PhisAddonJobSchedule;
+};
+/**
+ * One event this Add-on announces under its own name.
+ *
+ * Declared like a job or a route: the id, its emitter's own id in front, is part of the manifest and
+ * therefore of the digest, so what an installed Add-on can say to the others is readable at install.
+ * Emitting an undeclared event is refused. `audience` says who may listen: every Add-on of the Site
+ * that declares a handler for it, which is the default, because the operator installed each of them;
+ * or `self`, for an Add-on that uses the outbox to hand work to its own handler after the fact.
+ */
+export type PhisAddonEmittedEventDescriptor = {
+    id: PhisAddonEmittedEventId;
+    description?: string;
+    audience?: "stage" | "self";
 };
 /**
  * One setting an operator may configure for this Add-on.
@@ -259,6 +303,13 @@ export type PhisAddonManifestV1 = {
      * Add-on that declares them and links nothing is told nothing.
      */
     eventHandlers?: PhisAddonEventHandlerDescriptor[];
+    /**
+     * The events this Add-on emits. Absent means none, and an emit of anything is refused.
+     *
+     * Optional like `eventHandlers`. Declaring an event is not delivering it: a row is written only for
+     * an Add-on of the Site that declares a handler for the id, and none at all where nobody listens.
+     */
+    emits?: PhisAddonEmittedEventDescriptor[];
     /**
      * What an operator may configure. Absent means nothing is.
      *

package/dist/addon.js

@@ -13,3 +13,13 @@
  */
 export const PHIS_ADDON_MANIFEST_VERSION = 1;
 export const PHIS_ADDON_ABI_VERSION = 1;
+/**
+ * The steps a job may run at. Every step divides the hour or the day, so the moments a schedule names
+ * fall on the clock -- `5m` is :00, :05, :10 -- and every instance of Core computes the same moment
+ * from the same clock without asking another.
+ *
+ * Nothing shorter than five minutes: a job that has to look more often than that is polling for an
+ * event, and an event is what it should be given. Jobs run per Site, so a short step multiplies by
+ * the Sites of a stage, and the services a job reads from have quotas of their own.
+ */
+export const PHIS_ADDON_JOB_INTERVALS = ["5m", "15m", "30m", "hourly", "daily", "weekly"];

package/dist/capabilities.d.ts

@@ -12,7 +12,7 @@
  * at the point where it made the mistake.
  */
 import type { PhisAssetsCapabilityV1 } from "./assets.js";
-import type { PhisAddonThreadEventId } from "./core.js";
+import type { PhisAddonEmittedEventId, PhisAddonThreadEventId } from "./core.js";
 import type { PhisPaymentChangedEventFacts, PhisPaymentNotificationsCapabilityV1, PhisPaymentsCapabilityV1 } from "./payments.js";
 import type { PhisDataCapabilityV1 } from "./queries.js";
 import type { PhisResourceLinksCapabilityV1 } from "./resource-links.js";
@@ -109,6 +109,52 @@ export type PhisAddonCapabilities = {
     paymentNotifications?: PhisPaymentNotificationsCapabilityV1;
     /** Writing to a person about an occasion this Add-on declared; Core owns the frame and the sending. */
     notifications?: PhisNotificationsCapabilityV1;
+    /** Announcing an event this Add-on declared under its own name; Core owns the outbox and the delivery. */
+    events?: PhisEventsCapabilityV1;
+};
+/**
+ * The events capability: `@phis/server/events:v1`.
+ *
+ * An Add-on says that something happened; Core writes one outbox row per Add-on of this Site that
+ * declares a handler for the event, and delivers them the way it delivers its own events -- after the
+ * fact, in order, retried until they arrive. Emitting is only a write to the outbox, so it is cheap and
+ * never waits for a listener.
+ *
+ * `facts` are values about what happened, as JSON, bounded in size, and never references into another
+ * Add-on's tables: a listener runs with authority over its own tables only, and a fact it cannot read
+ * is a fact it should have been handed. `dedupeKey` makes a repeated emit safe -- a second call with
+ * the same key writes nothing for a listener already owed the first.
+ *
+ * Refused: an event the manifest does not declare under `emits`, a call from an unverified hook, and
+ * an emit from a handler already at `PHIS_ADDON_EVENT_MAX_HOPS`. Answers how many listeners were
+ * written for; zero means nobody on this Site listens, which is not a failure.
+ */
+export type PhisEventsCapabilityV1 = {
+    emit(input: PhisAddonEmitEventInput): Promise<{
+        recipients: number;
+    }>;
+};
+export type PhisAddonEmitEventInput = {
+    event: PhisAddonEmittedEventId;
+    facts?: Readonly<Record<string, unknown>>;
+    /** Unique within the Site and the event; a second emit with the same key writes nothing new. */
+    dedupeKey?: string;
+};
+/**
+ * What a listener is handed about an event another Add-on -- or the same one -- emitted.
+ *
+ * The emitter's id says who, `occurredAt` when (the moment the outbox row was written), `hop` how many
+ * handlers the chain has passed through so far, and `facts` what the emitter said. `dedupeKey` is the
+ * emitter's, where it gave one; the delivery's own key, stable across retries, is `deliveryId` on the
+ * context, as for every event.
+ */
+export type PhisAddonEmittedEventSubject = {
+    kind: "emitted";
+    emitter: string;
+    occurredAt: string;
+    hop: number;
+    dedupeKey: string | null;
+    facts: Readonly<Record<string, unknown>>;
 };
 /**
  * The roles capability: `@phis/server/roles:v1`.
@@ -399,8 +445,9 @@ export type PhisSettingsCapabilityV1 = {
  *
  * No request, no headers, and above all no actor: a job is the Add-on acting on its own data, not a
  * person acting through it. That is why the row-level ladder does not apply inside one, and why a job
- * is reachable only from `phis addon job run` and never from a route -- an Add-on that could start its
- * own job from a request would have built itself a way around the ladder.
+ * is started only by Core's scheduler at the moments its `schedule` names, or by an operator with
+ * `phis addon job`, and never from a route -- an Add-on that could start its own job from a request
+ * would have built itself a way around the ladder.
  */
 export type PhisAddonJobContext = {
     addonId: string;
@@ -434,7 +481,10 @@ export type PhisAddonEventFacts = {
         threadId: number;
         messageId: number | null;
     };
-} | PhisPaymentChangedEventFacts;
+} | PhisPaymentChangedEventFacts | {
+    event: PhisAddonEmittedEventId;
+    subject: PhisAddonEmittedEventSubject;
+};
 export type PhisAddonEventContext = PhisAddonEventFacts & {
     addonId: string;
     /** This delivery, stable across retries, so a handler can recognise one it already settled. */

package/dist/core.d.ts

@@ -50,6 +50,8 @@ export declare const PHIS_CORE_CAPABILITIES: {
     readonly paymentNotifications: "@phis/server/payment-notifications:v1";
     /** Writing to a person about an occasion the Add-on declared, with Core owning frame and transport. */
     readonly notifications: "@phis/server/notifications:v1";
+    /** Announcing an event this Add-on declared under its own name, for the Add-ons of this Site that listen. */
+    readonly events: "@phis/server/events:v1";
 };
 export type PhisCoreCapabilityId = (typeof PHIS_CORE_CAPABILITIES)[keyof typeof PHIS_CORE_CAPABILITIES];
 /**
@@ -75,8 +77,27 @@ export declare const PHIS_ADDON_EVENTS: {
     readonly paymentChanged: "payment.changed";
 };
 export type PhisAddonThreadEventId = Exclude<(typeof PHIS_ADDON_EVENTS)[keyof typeof PHIS_ADDON_EVENTS], "payment.changed">;
-/** Delivered v1 event vocabulary, discriminated by its owned subject. */
-export type PhisAddonEventId = PhisAddonThreadEventId | PhisPaymentChangedEventFacts["event"];
+/** The events Core itself emits: the thread events and the Payment event. */
+export type PhisCoreEventId = PhisAddonThreadEventId | PhisPaymentChangedEventFacts["event"];
+/**
+ * An event an Add-on emits, named under the Add-on that emits it: `@scope/name:what.happened`.
+ *
+ * The emitter's own id is the first half, so two Add-ons cannot name the same event and a reader of
+ * a manifest sees who announces it without looking anything up. The second half is the Add-on's own
+ * word for it, `^[a-z][a-z0-9.-]*$`, the shape Core's own event names have. Core's names stay bare:
+ * a bare name is Core's, a prefixed one is an Add-on's, and the two can never be confused.
+ */
+export type PhisAddonEmittedEventId = `@${string}/${string}:${string}`;
+/** Delivered v1 event vocabulary: Core's own events, and what an installed Add-on emits. */
+export type PhisAddonEventId = PhisCoreEventId | PhisAddonEmittedEventId;
+/**
+ * How many Add-ons an event may pass through.
+ *
+ * An Add-on that emits inside an event handler writes an event with the incoming hop plus one. A
+ * handler that answers every event with an event, met by another doing the same, would otherwise
+ * write forever; at this depth the emit is refused and logged instead of delivered.
+ */
+export declare const PHIS_ADDON_EVENT_MAX_HOPS = 4;
 /**
  * The Core-owned service kinds an Add-on may implement.
  *

package/dist/core.js

@@ -49,6 +49,8 @@ export const PHIS_CORE_CAPABILITIES = {
     paymentNotifications: "@phis/server/payment-notifications:v1",
     /** Writing to a person about an occasion the Add-on declared, with Core owning frame and transport. */
     notifications: "@phis/server/notifications:v1",
+    /** Announcing an event this Add-on declared under its own name, for the Add-ons of this Site that listen. */
+    events: "@phis/server/events:v1",
 };
 /**
  * What Core tells an Add-on about after the fact.
@@ -72,6 +74,14 @@ export const PHIS_ADDON_EVENTS = {
     threadLinkRemoved: "thread.link.removed",
     paymentChanged: "payment.changed",
 };
+/**
+ * How many Add-ons an event may pass through.
+ *
+ * An Add-on that emits inside an event handler writes an event with the incoming hop plus one. A
+ * handler that answers every event with an event, met by another doing the same, would otherwise
+ * write forever; at this depth the emit is refused and logged instead of delivered.
+ */
+export const PHIS_ADDON_EVENT_MAX_HOPS = 4;
 /**
  * The Core-owned service kinds an Add-on may implement.
  *

package/dist/search.d.ts

@@ -0,0 +1,96 @@
+/**
+ * The Areas a search index covers: a visitor's Public Site and the App a signed-in member reaches.
+ *
+ * Admin, Editor, Builder and Accounting are the operator's chrome, not Pages anybody searches, and a
+ * document set declared for one of them is refused rather than kept.
+ */
+export declare const PHI_SEARCH_INDEXED_AREA_MASK: number;
+/** The URL parameter the search box writes and the results Widget reads. */
+export declare const PHI_SEARCH_QUERY_PARAM = "q";
+/** A query shorter than this is not a search; two letters match too much to be an answer. */
+export declare const PHI_SEARCH_MIN_QUERY_LENGTH = 2;
+export declare const PHI_SEARCH_MAX_QUERY_LENGTH = 200;
+export declare const PHI_SEARCH_DEFAULT_LIMIT = 20;
+export declare const PHI_SEARCH_MAX_LIMIT = 50;
+/** How many documents one set may carry; a Site with more Pages than this is a different product. */
+export declare const PHI_SEARCH_MAX_DOCUMENTS = 5000;
+export declare const PHI_SEARCH_MAX_PATH_LENGTH = 512;
+export declare const PHI_SEARCH_MAX_TITLE_LENGTH = 512;
+export declare const PHI_SEARCH_MAX_DESCRIPTION_LENGTH = 2048;
+/** The text of one Page, as indexed; the words beyond it are not searched. */
+export declare const PHI_SEARCH_MAX_TEXT_LENGTH = 200000;
+/** One Page in one language, as the Site read it when the set was built. */
+export type PhiSearchDocument = {
+    /** The Page's address within its Area, `/docs/install`, as a link to it is written. */
+    path: string;
+    title: string;
+    description: string;
+    /** The Page's words, in reading order, with no markup; a heading is a line like any other. */
+    text: string;
+};
+/**
+ * Every document of one Area in one language, replacing whatever the set held before.
+ *
+ * `fingerprint` names what the set was built from -- the live revisions, the route table, the Module
+ * addresses -- so phis can tell a set it already holds from a new one and several Site processes
+ * noticing the same publish write it once.
+ */
+export type PhiSearchIndexSet = {
+    areaMask: number;
+    locale: string;
+    fingerprint: string;
+    documents: PhiSearchDocument[];
+};
+/** What phis holds of one set: enough for a Site to decide whether to build it again. */
+export type PhiSearchIndexState = {
+    areaMask: number;
+    locale: string;
+    fingerprint: string;
+    documentCount: number;
+    /** ISO instant. */
+    indexedAt: string;
+};
+export type PhiSearchIndexWriteResult = {
+    /** `false` when the set phis holds already carries this fingerprint, and nothing was written. */
+    accepted: boolean;
+    state: PhiSearchIndexState;
+};
+/** A piece of a snippet; a `match` piece is one of the query's words as it stands in the text. */
+export type PhiSearchSnippetSegment = {
+    text: string;
+    match: boolean;
+};
+export type PhiSearchHit = {
+    path: string;
+    areaMask: number;
+    title: string;
+    description: string;
+    /** The passage around the best matches, in pieces; empty when the match is in the title alone. */
+    snippet: PhiSearchSnippetSegment[];
+    /** Higher is better; comparable within one answer only. */
+    rank: number;
+};
+export type PhiSearchResponse = {
+    /** The query as phis read it (`readPhiSearchQuery`). */
+    query: string;
+    locale: string;
+    /** The Areas that were searched, as a mask. */
+    areaMask: number;
+    hits: PhiSearchHit[];
+    /** How many documents match in all, of which `hits` are the first. */
+    total: number;
+};
+/**
+ * The query as both ends read it, or `null` for no query: whitespace collapsed, bounds applied.
+ *
+ * Length is measured after collapsing, so a visitor cannot pad past the ceiling with spaces, and a query
+ * over the ceiling is cut rather than refused -- the first two hundred characters are a search, the rest
+ * was never going to narrow it.
+ */
+export declare function readPhiSearchQuery(value: unknown): string | null;
+/**
+ * The words of a query, as both ends count them: letters and digits of any script, lower-cased,
+ * everything else a separator. phis builds its text query from these; the Site marks them in what it
+ * shows. A word is at most 64 characters, so a pasted token does not become a search for nothing.
+ */
+export declare function tokenizePhiSearchQuery(query: string): string[];

package/dist/search.js

@@ -0,0 +1,66 @@
+/**
+ * What a Site and phis say to each other about searching the Site's own Pages.
+ *
+ * The texts a visitor searches are not phis's to know: a Page's words stand in Widget configs, in content
+ * phis stores without knowing which Page shows it, and in documents a Widget fetches from elsewhere while
+ * the Page is drawn. Only the Site, resolving a Page the way a visitor's request resolves it, sees the
+ * whole text. So the Site writes the documents, one per Page and language, and phis keeps them, indexes
+ * them and answers a query with the Pages that match -- which is the half a database does well.
+ *
+ * Both halves read the same shapes: what the Site sends (`PhiSearchIndexSet`), what phis answers
+ * (`PhiSearchResponse`), and the query's admission (`readPhiSearchQuery`), because a query the Site shows
+ * as "too short" and phis would have answered -- or the reverse -- is a visitor told two things at once.
+ */
+import { PhiCmsVisibilityContext } from "./cms.js";
+/**
+ * The Areas a search index covers: a visitor's Public Site and the App a signed-in member reaches.
+ *
+ * Admin, Editor, Builder and Accounting are the operator's chrome, not Pages anybody searches, and a
+ * document set declared for one of them is refused rather than kept.
+ */
+export const PHI_SEARCH_INDEXED_AREA_MASK = PhiCmsVisibilityContext.PublicArea | PhiCmsVisibilityContext.AppArea;
+/** The URL parameter the search box writes and the results Widget reads. */
+export const PHI_SEARCH_QUERY_PARAM = "q";
+/** A query shorter than this is not a search; two letters match too much to be an answer. */
+export const PHI_SEARCH_MIN_QUERY_LENGTH = 2;
+export const PHI_SEARCH_MAX_QUERY_LENGTH = 200;
+export const PHI_SEARCH_DEFAULT_LIMIT = 20;
+export const PHI_SEARCH_MAX_LIMIT = 50;
+/** How many documents one set may carry; a Site with more Pages than this is a different product. */
+export const PHI_SEARCH_MAX_DOCUMENTS = 5000;
+export const PHI_SEARCH_MAX_PATH_LENGTH = 512;
+export const PHI_SEARCH_MAX_TITLE_LENGTH = 512;
+export const PHI_SEARCH_MAX_DESCRIPTION_LENGTH = 2048;
+/** The text of one Page, as indexed; the words beyond it are not searched. */
+export const PHI_SEARCH_MAX_TEXT_LENGTH = 200_000;
+/**
+ * The query as both ends read it, or `null` for no query: whitespace collapsed, bounds applied.
+ *
+ * Length is measured after collapsing, so a visitor cannot pad past the ceiling with spaces, and a query
+ * over the ceiling is cut rather than refused -- the first two hundred characters are a search, the rest
+ * was never going to narrow it.
+ */
+export function readPhiSearchQuery(value) {
+    if (typeof value !== "string")
+        return null;
+    const collapsed = value.replace(/\s+/gu, " ").trim();
+    if (collapsed.length < PHI_SEARCH_MIN_QUERY_LENGTH)
+        return null;
+    return collapsed.length > PHI_SEARCH_MAX_QUERY_LENGTH
+        ? collapsed.slice(0, PHI_SEARCH_MAX_QUERY_LENGTH).trimEnd()
+        : collapsed;
+}
+/**
+ * The words of a query, as both ends count them: letters and digits of any script, lower-cased,
+ * everything else a separator. phis builds its text query from these; the Site marks them in what it
+ * shows. A word is at most 64 characters, so a pasted token does not become a search for nothing.
+ */
+export function tokenizePhiSearchQuery(query) {
+    const words = [];
+    for (const match of query.toLowerCase().matchAll(/[\p{L}\p{N}]+/gu)) {
+        const word = match[0].slice(0, 64);
+        if (!words.includes(word))
+            words.push(word);
+    }
+    return words;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phis/contracts",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "license": "Apache-2.0",
   "type": "module",
   "publishConfig": {
@@ -70,6 +70,11 @@
       "import": "./dist/resource-links.js",
       "default": "./dist/resource-links.js"
     },
+    "./search": {
+      "types": "./dist/search.d.ts",
+      "import": "./dist/search.js",
+      "default": "./dist/search.js"
+    },
     "./server-capabilities": {
       "types": "./dist/server-capabilities.d.ts",
       "import": "./dist/server-capabilities.js",