@kumwe/studio-testkit 0.1.0-alpha.7 → 0.1.0-beta.2

package/dist/http-host-adapter.d.ts

@@ -1,74 +1,22 @@
+import { type HttpAuthenticationResolver, type HttpFetchLike, type HttpRequestInit, type HttpSchemaValidator, type HttpTimeoutHandle } from '@kumwe/studio-core';
 import { type HostAdapter } from '@kumwe/studio-protocol';
-/**
- * Minimal structural view of an HTTP response the adapter needs: the status
- * code and the raw body text. Deliberately narrower than any platform
- * response class so implementations from any runtime satisfy it.
- */
-export interface HttpResponseLike {
-    status: number;
-    text(): Promise<string>;
-}
-/** The request shape the adapter hands to the injected transport. */
-export interface HttpRequestInit {
-    body: string;
-    headers: Record<string, string>;
-    method: 'POST';
-    /** Opaque abort signal produced by the injected timeout factory, if any. */
-    signal?: unknown;
-}
-/**
- * The injected fetch-like transport — the adapter's portability seam.
- *
- * Testkit source is deliberately free of host globals (no fetch, no DOM, no
- * Node), so the embedder supplies the platform transport: a Node test injects
- * a `node:http`-backed implementation, a browser host would inject the
- * platform fetch, and either stays outside this package. The function must
- * resolve with the terminal HTTP response (any status) and reject only for
- * transport-level failures: network refusal, connection loss, or an abort
- * raised by the injected timeout signal.
- */
-export type HttpFetchLike = (url: string, init: HttpRequestInit) => Promise<HttpResponseLike>;
-/**
- * An abort signal handle minted per request by the injected timeout factory.
- * `signal` is passed through to the transport untouched; `release` (when
- * present) is invoked once the request settles so timer-backed factories can
- * clean up.
- */
-export interface HttpTimeoutHandle {
-    release?(): void;
-    signal: unknown;
-}
+export { HTTP_HOST_OPERATION_ROUTES } from '@kumwe/studio-core';
+export type { ConfiguredHttpHostAdapterOptions, HttpAuthenticationConfiguration, HttpAuthenticationRequest, HttpAuthenticationResolver, HttpBearerTokenAuthentication, HttpFetchLike, HttpHeaderTokenAuthentication, HttpHostOperationEndpoints, HttpHostOperationRoute, HttpHostRoutingConfiguration, HttpHostTransportConfiguration, HttpRequestInit, HttpResponseLike, HttpSameOriginSessionAuthentication, HttpTimeoutHandle, } from '@kumwe/studio-core';
+/** Historical conventional-route options retained only for test conformance. */
 export interface HttpHostAdapterOptions {
-    /**
-     * Second half of the portability seam: mints the per-request timeout
-     * signal. When omitted, requests carry no deadline. A rejection whose
-     * reason is named `AbortError` or `TimeoutError` is mapped to the canonical
-     * deadline failure.
-     */
     createTimeoutSignal?: (timeoutMilliseconds: number) => HttpTimeoutHandle;
+    credentials?: HttpRequestInit['credentials'];
     fetchImplementation: HttpFetchLike;
-    /** Transport deadline handed to `createTimeoutSignal`. Defaults to 10 000. */
+    maximumResponseBytes?: number;
+    requestHeaders?: () => Readonly<Record<string, string>>;
+    resolveAuthentication?: HttpAuthenticationResolver;
     timeoutMilliseconds?: number;
+    validateSchema?: HttpSchemaValidator;
 }
 /**
- * A `HostAdapter` that speaks JSON over an injected fetch-like transport to a
- * host server: every port operation becomes
- * `POST {baseUrl}/ports/{port}/{operation}` with a
- * `{ arguments, context }` JSON body.
- *
- * Success responses (2xx) must carry a `HostPortResult` JSON body. Failure
- * responses that carry a guard-conforming `HostPortError` body are re-thrown
- * as that canonical error, so a host-authored category (with its safe
- * revision on conflicts) crosses the transport intact. Everything else is
- * mapped onto the canonical host error categories without disclosing
- * transport details: network refusal and deadline expiry become
- * `unavailable`, HTTP statuses map by class (401 `unauthenticated`, 403
- * `forbidden`, 404 `not-found`, 409 `conflict`, 413 `limit-exceeded`, 422
- * `validation-failed`, 429 `rate-limited`, 5xx `internal`/`unavailable`), and
- * a malformed body — unparseable JSON, a result without `value`, or an error
- * document the guard rejects — becomes `internal`. Every rejection is a
- * `TestbedHostError` whose `error` satisfies `isHostPortError`, and no
- * message ever echoes response bodies, addresses, or underlying reasons.
+ * Backward-compatible testkit facade over the production core transport.
+ * Canonical `HostPortFailure` rejections are translated to the historical
+ * `TestbedHostError` subclass without duplicating any HTTP behavior.
  */
 export declare function createHttpHostAdapter(baseUrl: string, options: HttpHostAdapterOptions): HostAdapter;
 //# sourceMappingURL=http-host-adapter.d.ts.map

package/dist/http-host-adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"http-host-adapter.d.ts","sourceRoot":"","sources":["../src/http-host-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,WAAW,EAqBjB,MAAM,wBAAwB,CAAC;AAGhC;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;CACzB;AAED,qEAAqE;AACrE,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,4EAA4E;IAC5E,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;AAE9F;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,OAAO,CAAC,IAAI,IAAI,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,sBAAsB;IACrC;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,CAAC,mBAAmB,EAAE,MAAM,KAAK,iBAAiB,CAAC;IACzE,mBAAmB,EAAE,aAAa,CAAC;IACnC,8EAA8E;IAC9E,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AASD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,sBAAsB,GAC9B,WAAW,CA8Lb"}
+{"version":3,"file":"http-host-adapter.d.ts","sourceRoot":"","sources":["../src/http-host-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,0BAA0B,EAC/B,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACvB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAqB,KAAK,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAG7E,OAAO,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AAEhE,YAAY,EACV,gCAAgC,EAChC,+BAA+B,EAC/B,yBAAyB,EACzB,0BAA0B,EAC1B,6BAA6B,EAC7B,aAAa,EACb,6BAA6B,EAC7B,0BAA0B,EAC1B,sBAAsB,EACtB,4BAA4B,EAC5B,8BAA8B,EAC9B,eAAe,EACf,gBAAgB,EAChB,mCAAmC,EACnC,iBAAiB,GAClB,MAAM,oBAAoB,CAAC;AAE5B,gFAAgF;AAChF,MAAM,WAAW,sBAAsB;IACrC,mBAAmB,CAAC,EAAE,CAAC,mBAAmB,EAAE,MAAM,KAAK,iBAAiB,CAAC;IACzE,WAAW,CAAC,EAAE,eAAe,CAAC,aAAa,CAAC,CAAC;IAC7C,mBAAmB,EAAE,aAAa,CAAC;IACnC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,cAAc,CAAC,EAAE,MAAM,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACxD,qBAAqB,CAAC,EAAE,0BAA0B,CAAC;IACnD,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,cAAc,CAAC,EAAE,mBAAmB,CAAC;CACtC;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,sBAAsB,GAC9B,WAAW,CAiEb"}

package/dist/http-host-adapter.js

@@ -1,256 +1 @@
-import { isHostPortError, STUDIO_CONTRACT_VERSION, } from '@kumwe/studio-protocol';
-import { TestbedHostError } from './host-testbed.js';
-/**
- * A `HostAdapter` that speaks JSON over an injected fetch-like transport to a
- * host server: every port operation becomes
- * `POST {baseUrl}/ports/{port}/{operation}` with a
- * `{ arguments, context }` JSON body.
- *
- * Success responses (2xx) must carry a `HostPortResult` JSON body. Failure
- * responses that carry a guard-conforming `HostPortError` body are re-thrown
- * as that canonical error, so a host-authored category (with its safe
- * revision on conflicts) crosses the transport intact. Everything else is
- * mapped onto the canonical host error categories without disclosing
- * transport details: network refusal and deadline expiry become
- * `unavailable`, HTTP statuses map by class (401 `unauthenticated`, 403
- * `forbidden`, 404 `not-found`, 409 `conflict`, 413 `limit-exceeded`, 422
- * `validation-failed`, 429 `rate-limited`, 5xx `internal`/`unavailable`), and
- * a malformed body — unparseable JSON, a result without `value`, or an error
- * document the guard rejects — becomes `internal`. Every rejection is a
- * `TestbedHostError` whose `error` satisfies `isHostPortError`, and no
- * message ever echoes response bodies, addresses, or underlying reasons.
- */
-export function createHttpHostAdapter(baseUrl, options) {
-    const base = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
-    const timeoutMilliseconds = options.timeoutMilliseconds ?? 10_000;
-    let correlationSerial = 0;
-    function createError(failure) {
-        correlationSerial += 1;
-        const error = {
-            category: failure.category,
-            contractVersion: STUDIO_CONTRACT_VERSION,
-            correlationId: `http-transport-${correlationSerial}`,
-            kind: 'host-error',
-            message: { defaultMessage: failure.defaultMessage, key: failure.key },
-            retryable: failure.retryable,
-        };
-        return new TestbedHostError(error);
-    }
-    async function call(portName, operation, callArguments, context) {
-        const handle = options.createTimeoutSignal?.(timeoutMilliseconds);
-        let response;
-        try {
-            response = await options.fetchImplementation(`${base}/ports/${portName}/${operation}`, {
-                body: JSON.stringify({ arguments: callArguments, context }),
-                headers: { 'content-type': 'application/json' },
-                method: 'POST',
-                ...(handle === undefined ? {} : { signal: handle.signal }),
-            });
-        }
-        catch (reason) {
-            throw createError(classifyTransportFailure(reason));
-        }
-        finally {
-            handle?.release?.();
-        }
-        let bodyText;
-        try {
-            bodyText = await response.text();
-        }
-        catch {
-            throw createError(malformedResponse());
-        }
-        if (response.status >= 200 && response.status < 300) {
-            const parsed = parseJson(bodyText);
-            if (!isHostPortResult(parsed)) {
-                throw createError(malformedResponse());
-            }
-            const result = {
-                ...(parsed.revision === undefined ? {} : { revision: parsed.revision }),
-                value: parsed.value,
-            };
-            return result;
-        }
-        const parsed = parseJson(bodyText);
-        if (isHostPortError(parsed)) {
-            // The host authored a canonical error; transport it verbatim.
-            throw new TestbedHostError(parsed);
-        }
-        throw createError(statusFailure(response.status));
-    }
-    return {
-        artifact: {
-            dependencies(reference, context) {
-                return call('artifact', 'dependencies', { reference: asJson(reference) }, context);
-            },
-            load(reference, context) {
-                return call('artifact', 'load', { reference: asJson(reference) }, context);
-            },
-            publish(reference, context) {
-                return call('artifact', 'publish', { reference: asJson(reference) }, context);
-            },
-            save(document, context) {
-                return call('artifact', 'save', { document: asJson(document) }, context);
-            },
-            unpublish(reference, context) {
-                return call('artifact', 'unpublish', { reference: asJson(reference) }, context);
-            },
-        },
-        localization: {
-            messages(locale, namespaces, context) {
-                return call('localization', 'messages', { locale, namespaces }, context);
-            },
-        },
-        media: {
-            abortUpload(uploadId, context) {
-                return call('media', 'abort-upload', { uploadId }, context);
-            },
-            authorizeUpload(request, context) {
-                return call('media', 'authorize-upload', { request: asJson(request) }, context);
-            },
-            completeUpload(uploadId, context) {
-                return call('media', 'complete-upload', { uploadId }, context);
-            },
-            get(assetId, context) {
-                return call('media', 'get', { assetId }, context);
-            },
-            importExternal(url, context) {
-                return call('media', 'import-external', { url }, context);
-            },
-            list(query, context) {
-                return call('media', 'list', { query: asJson(query) }, context);
-            },
-            uploadStatus(assetId, context) {
-                return call('media', 'upload-status', { assetId }, context);
-            },
-        },
-        permission: {
-            explain(operation, context) {
-                return call('permission', 'explain', { operation }, context);
-            },
-            refresh(context) {
-                return call('permission', 'refresh', {}, context);
-            },
-        },
-        preview: {
-            cancel(draftDigest, context) {
-                return call('preview', 'cancel', { draftDigest }, context);
-            },
-            render(payload, context) {
-                return call('preview', 'render', { payload: asJson(payload) }, context);
-            },
-        },
-        recovery: {
-            discard(context) {
-                return call('recovery', 'discard', {}, context);
-            },
-            load(context) {
-                return call('recovery', 'load', {}, context);
-            },
-            store(envelope, context) {
-                return call('recovery', 'store', { envelope }, context);
-            },
-        },
-        resource: {
-            search(query, context) {
-                return call('resource', 'search', { query: asJson(query) }, context);
-            },
-        },
-        telemetry: {
-            emit(event, context) {
-                return call('telemetry', 'emit', { event: asJson(event) }, context);
-            },
-        },
-    };
-}
-/** Serializable typed values cross the wire as their JSON projections. */
-function asJson(value) {
-    return JSON.parse(JSON.stringify(value));
-}
-function parseJson(text) {
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return undefined;
-    }
-}
-function isHostPortResult(value) {
-    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
-        return false;
-    }
-    const record = value;
-    if (!Object.hasOwn(record, 'value')) {
-        return false;
-    }
-    const revision = record.revision;
-    if (revision !== undefined && (typeof revision !== 'string' || revision.length === 0)) {
-        return false;
-    }
-    return Object.keys(record).every((key) => key === 'value' || key === 'revision');
-}
-function classifyTransportFailure(reason) {
-    const name = typeof reason === 'object' && reason !== null && 'name' in reason ? reason.name : undefined;
-    if (name === 'AbortError' || name === 'TimeoutError') {
-        // The injected deadline signal fired before the host answered.
-        return {
-            category: 'unavailable',
-            defaultMessage: 'The host did not respond within the transport deadline.',
-            key: 'studio.testkit/http-timeout',
-            retryable: true,
-        };
-    }
-    return {
-        category: 'unavailable',
-        defaultMessage: 'The host could not be reached.',
-        key: 'studio.testkit/http-unreachable',
-        retryable: true,
-    };
-}
-function malformedResponse() {
-    return {
-        category: 'internal',
-        defaultMessage: 'The host response could not be interpreted.',
-        key: 'studio.testkit/http-malformed-response',
-        retryable: false,
-    };
-}
-function statusFailure(status) {
-    const category = categoryForStatus(status);
-    return {
-        category,
-        defaultMessage: 'The host rejected the request.',
-        key: `studio.testkit/http-status-${category}`,
-        retryable: category === 'rate-limited' || category === 'unavailable',
-    };
-}
-function categoryForStatus(status) {
-    switch (status) {
-        case 401:
-            return 'unauthenticated';
-        case 403:
-            return 'forbidden';
-        case 404:
-            return 'not-found';
-        case 408:
-            return 'unavailable';
-        case 409:
-            return 'conflict';
-        case 413:
-            return 'limit-exceeded';
-        case 422:
-            return 'validation-failed';
-        case 429:
-            return 'rate-limited';
-        case 502:
-        case 503:
-        case 504:
-            return 'unavailable';
-        default:
-            if (status >= 400 && status < 500) {
-                return 'invalid-request';
-            }
-            return 'internal';
-    }
-}
-//# sourceMappingURL=http-host-adapter.js.map
+import{HTTP_HOST_OPERATION_ROUTES as e,createHttpHostAdapter as t}from"@kumwe/studio-core";import{isHostPortFailure as n}from"@kumwe/studio-protocol";import{TestbedHostError as r}from"./host-testbed.js";export{HTTP_HOST_OPERATION_ROUTES}from"@kumwe/studio-core";export function createHttpHostAdapter(n,r){let i=r.createTimeoutSignal,s=a(n),l=Object.fromEntries(e.map(e=>[e,`${s}/ports/${e}`])),u=r.timeoutMilliseconds??1e4,d=r.maximumResponseBytes??67108864;if(!Number.isSafeInteger(u)||u<=0)throw TypeError(`timeoutMilliseconds must be a positive safe integer.`);if(!Number.isSafeInteger(d)||d<=0)throw TypeError(`maximumResponseBytes must be a positive safe integer.`);let f=async(e,t)=>{let n;try{n=o(t.headers,r.requestHeaders?.())}catch{let e=Error(`The testkit HTTP request headers are invalid.`);throw e.name=`InvalidRequestError`,e}let i=await r.fetchImplementation(e,{...t,credentials:r.credentials??`same-origin`,headers:n});return{...i.contentType===void 0?{}:{contentType:i.contentType},status:i.status,text:()=>i.text(d)}};return c(t({authentication:{credentials:`omit`,expiresAt:`1970-01-01T00:10:00Z`,headerName:`X-Studio-Testkit-Transport`,issuedAt:`1970-01-01T00:00:00Z`,kind:`header-token`,token:`conformance`},kind:`http`,maximumResponseBytes:Math.min(67108864,Math.max(1024,d)),requestTimeoutMilliseconds:1e4,routing:{endpoints:l,kind:`operation-map`}},{...i===void 0?{}:{createTimeoutSignal:()=>i(u)},currentTimeMilliseconds:()=>0,fetchImplementation:f,...r.resolveAuthentication===void 0?{}:{resolveAuthentication:r.resolveAuthentication},...r.validateSchema===void 0?{}:{validateSchema:r.validateSchema}}))}function a(e){if(e===``)return``;if(e.trim()!==e||/\s/u.test(e)||e.includes(`?`)||e.includes(`#`)||e.includes(`\\`))throw TypeError(`baseUrl must not contain whitespace, a query, or a fragment.`);let t=e.endsWith(`/`)?e.slice(0,-1):e,n;if(t.startsWith(`https://`)||t.startsWith(`http://`)){let e=t.indexOf(`://`)+3,r=t.indexOf(`/`,e),i=r===-1?t.slice(e):t.slice(e,r);if(i.length===0||i.includes(`@`))throw TypeError(`baseUrl must contain a host and must not embed credentials.`);n=r===-1?``:t.slice(r)}else{if(!t.startsWith(`/`)||t.startsWith(`//`))throw TypeError(`baseUrl must be an HTTP(S) URL or a same-origin absolute path.`);n=t}if(n.includes(`//`))throw TypeError(`baseUrl path must be normalized without empty segments.`);for(let e of n.split(`/`))if(e===`.`||e===`..`||/%2e/iu.test(e))throw TypeError(`baseUrl path must not contain dot segments.`);return t}function o(e,t){let n={...e};for(let[e,r]of Object.entries(t??{})){let t=e.toLowerCase();if(e.length>100||!/^[!#$%&'*+.^_`|~0-9a-z-]+$/u.test(t)||r.length>8192||r.trim()!==r||s(r)||t===`accept`||t===`content-type`||t===`x-studio-operation`||Object.hasOwn(n,t))throw TypeError(`Invalid HTTP request header.`);n[t]=r}return n}function s(e){for(let t=0;t<e.length;t+=1){let n=e.charCodeAt(t);if(n<=8||n>=10&&n<=31||n===127||n>255)return!0}return!1}function c(e){return Object.fromEntries(Object.entries(e).map(([e,t])=>[e,l(t)]))}function l(e){return new Proxy(e,{get(e,t,i){let a=Reflect.get(e,t,i);return typeof a==`function`?(...t)=>Promise.resolve(Reflect.apply(a,e,t)).catch(e=>{throw n(e)&&!(e instanceof r)?new r(e.error):e}):a}})}

package/dist/http-host-responder.d.ts

@@ -0,0 +1,58 @@
+import { type AuthoringPort, type QualifiedName } from '@kumwe/studio-protocol';
+import { type AuthoringHttpRoute, type HttpSchemaValidator } from './http-authoring-contract.js';
+export interface HttpResponderRequest {
+    /** Raw JSON body after the HTTP server has decoded transport bytes as UTF-8. */
+    body: string;
+    /** Header names are matched case-insensitively. Duplicate spellings fail closed. */
+    headers: Readonly<Record<string, string | undefined>>;
+    method: string;
+    /** Pathname only. A query string is not a Studio port route. */
+    path: string;
+}
+export interface HttpResponderResponse {
+    body: string;
+    headers: Readonly<Record<string, string>>;
+    status: number;
+}
+export interface HttpTransportSecurityDecision {
+    /** Authentication was derived from trusted transport evidence, never the JSON body. */
+    authenticated: boolean;
+    /** A CSRF token, strict same-origin proof, or non-browser service credential bound this call. */
+    requestIntegrity: boolean;
+}
+export interface HttpTransportSecurityInput {
+    capability: QualifiedName;
+    headers: Readonly<Record<string, string | undefined>>;
+    method: 'POST';
+    mutating: boolean;
+    path: string;
+    route: AuthoringHttpRoute;
+}
+export type HttpTransportSecurityVerifier = (input: HttpTransportSecurityInput) => HttpTransportSecurityDecision | Promise<HttpTransportSecurityDecision>;
+/**
+ * Validates one value against the exact canonical schema reference supplied
+ * by the responder. A PHP host performs the equivalent call in its PHP JSON
+ * Schema library; the reference responder deliberately does not own Ajv.
+ */
+export interface AuthoringHttpResponderOptions {
+    /** Defaults to 64 MiB; hosts may set a stricter deployment-specific limit. */
+    maximumRequestBytes?: number;
+    /** Defaults to `/ports`. */
+    routePrefix?: string;
+    validateSchema: HttpSchemaValidator;
+    /** Required fail-closed authentication plus CSRF/origin/service-integrity boundary. */
+    verifyTransportSecurity: HttpTransportSecurityVerifier;
+}
+/**
+ * Creates a platform-neutral reference responder for all seven contextual
+ * authoring routes. It receives and returns plain values, so an HTTP server,
+ * Service Worker, browser mock, or PHP interoperability test can bind it
+ * without importing a server framework.
+ *
+ * The responder validates transport method/content type/size, performs the
+ * trusted authentication and request-integrity check before parsing JSON,
+ * validates the exact operation schema, checks capability and resource
+ * context binding, and only then invokes the host-authoritative port.
+ */
+export declare function createAuthoringHttpResponder(authoring: AuthoringPort, options: AuthoringHttpResponderOptions): (request: HttpResponderRequest) => Promise<HttpResponderResponse>;
+//# sourceMappingURL=http-host-responder.d.ts.map

package/dist/http-host-responder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-host-responder.d.ts","sourceRoot":"","sources":["../src/http-host-responder.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,aAAa,EAalB,KAAK,aAAa,EACnB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAIL,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACzB,MAAM,8BAA8B,CAAC;AAEtC,MAAM,WAAW,oBAAoB;IACnC,gFAAgF;IAChF,IAAI,EAAE,MAAM,CAAC;IACb,oFAAoF;IACpF,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC;IACtD,MAAM,EAAE,MAAM,CAAC;IACf,gEAAgE;IAChE,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC1C,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,6BAA6B;IAC5C,uFAAuF;IACvF,aAAa,EAAE,OAAO,CAAC;IACvB,iGAAiG;IACjG,gBAAgB,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,0BAA0B;IACzC,UAAU,EAAE,aAAa,CAAC;IAC1B,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC;IACtD,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,OAAO,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,kBAAkB,CAAC;CAC3B;AAED,MAAM,MAAM,6BAA6B,GAAG,CAC1C,KAAK,EAAE,0BAA0B,KAC9B,6BAA6B,GAAG,OAAO,CAAC,6BAA6B,CAAC,CAAC;AAE5E;;;;GAIG;AACH,MAAM,WAAW,6BAA6B;IAC5C,8EAA8E;IAC9E,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,4BAA4B;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,mBAAmB,CAAC;IACpC,uFAAuF;IACvF,uBAAuB,EAAE,6BAA6B,CAAC;CACxD;AA8CD;;;;;;;;;;GAUG;AACH,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,aAAa,EACxB,OAAO,EAAE,6BAA6B,GACrC,CAAC,OAAO,EAAE,oBAAoB,KAAK,OAAO,CAAC,qBAAqB,CAAC,CA0JnE"}

package/dist/http-host-responder.js

@@ -0,0 +1 @@
+import{isHostPortFailure as e,STUDIO_CONTRACT_VERSION as t}from"@kumwe/studio-protocol";import{AUTHORING_HTTP_OPERATIONS as n,AUTHORING_HTTP_OPERATIONS_BY_ROUTE as r}from"./http-authoring-contract.js";const i=Object.freeze({"cache-control":`no-store`,"content-type":`application/json; charset=utf-8`,"x-content-type-options":`nosniff`}),a=Object.freeze({"authoring/list-types":(e,t)=>e.listTypes(t.arguments.query,t.context),"authoring/plan-save":(e,t)=>e.planSave(t.arguments.intent,t.context),"authoring/resolve-target":(e,t)=>e.resolveTarget(t.arguments.request,t.context),"authoring/save-as-new-type":(e,t)=>e.saveAsNewType(t.arguments.request,t.context),"authoring/save-item":(e,t)=>e.saveItem(t.arguments.request,t.context),"authoring/save-new-type-version":(e,t)=>e.saveNewTypeVersion(t.arguments.request,t.context),"authoring/start":(e,t)=>e.start(t.arguments.request,t.context)});export function createAuthoringHttpResponder(n,r){let i=r.maximumRequestBytes??67108864;if(!Number.isSafeInteger(i)||i<=0)throw TypeError(`maximumRequestBytes must be a positive safe integer.`);let o=c(r.routePrefix??`/ports`),y=0,b=(e,n,r,i=!1)=>(y+=1,h({category:e,contractVersion:t,correlationId:`http-responder/${y}`,kind:`host-error`,message:{defaultMessage:r,key:n},retryable:i},m(e)));return async t=>{let c=s(t.path,o);if(c===void 0)return b(`not-found`,`studio.testkit/http-route-not-found`,`The requested Studio host operation is unavailable.`);if(t.method!==`POST`)return _(b(`invalid-request`,`studio.testkit/http-method-invalid`,`Studio host operations require POST.`));if(!u(l(t.headers,`content-type`)))return b(`invalid-request`,`studio.testkit/http-content-type-invalid`,`Studio host operations require an application/json content type.`);if(v(t.body)>i)return b(`limit-exceeded`,`studio.testkit/http-request-too-large`,`The Studio host request exceeds the configured transport limit.`);let y;try{y=await r.verifyTransportSecurity({capability:c.capability,headers:t.headers,method:`POST`,mutating:c.mutating,path:t.path,route:c.route})}catch{return b(`internal`,`studio.testkit/http-security-check-failed`,`The host could not verify request security.`)}if(!y.authenticated)return b(`unauthenticated`,`studio.testkit/http-unauthenticated`,`Authentication is required for Studio authoring.`);if(!y.requestIntegrity)return b(`forbidden`,`studio.testkit/http-request-integrity-failed`,`The Studio authoring request failed request-integrity verification.`);let x=d(t.body);if(x===void 0)return b(`invalid-request`,`studio.testkit/http-request-malformed`,`The Studio host request body is not valid JSON.`);let S;try{S=r.validateSchema(c.requestSchema,x)}catch{return b(`internal`,`studio.testkit/http-schema-validator-failed`,`The host could not validate the Studio request.`)}if(!S||!f(x)||x.context.operationId!==c.capability)return b(`invalid-request`,`studio.testkit/http-request-invalid`,`The Studio host request does not match the operation contract.`);if(!p(c.route,x))return b(`invalid-request`,`studio.testkit/http-resource-context-mismatch`,`The operation resource context does not match the request envelope.`);let C;try{C=await a[c.route](n,x)}catch(t){return e(t)?h(t.error,m(t.error.category)):b(`internal`,`studio.testkit/http-host-failure`,`The host could not complete the Studio operation.`)}try{S=r.validateSchema(c.responseSchema,C)}catch{S=!1}return S?g(200,C):b(`internal`,`studio.testkit/http-response-invalid`,`The host produced an invalid Studio operation result.`)}}function s(e,t){if(!e.startsWith(`${t}/`)||e.includes(`?`)||e.includes(`#`))return;let n=e.slice(t.length+1);return r.get(n)}function c(e){if(!e.startsWith(`/`)||e.includes(`?`)||e.includes(`#`))throw TypeError(`routePrefix must be an absolute pathname without a query or fragment.`);let t=e.endsWith(`/`)?e.slice(0,-1):e;if(t.length===0||t.includes(`//`))throw TypeError(`routePrefix must identify one normalized absolute pathname.`);return t}function l(e,t){let n=Object.entries(e).filter(([e])=>e.toLowerCase()===t);return n.length===1?n[0]?.[1]:void 0}function u(e){return e?.split(`;`,1)[0]?.trim().toLowerCase()===`application/json`}function d(e){try{return JSON.parse(e)}catch{return}}function f(e){if(typeof e!=`object`||!e||Array.isArray(e))return!1;let t=e;return typeof t.arguments==`object`&&t.arguments!==null&&!Array.isArray(t.arguments)&&typeof t.context==`object`&&t.context!==null&&!Array.isArray(t.context)}function p(e,t){let r;switch(e){case n.resolveTarget.route:case n.start.route:r=t.arguments.request?.resourceContext;break;case n.listTypes.route:r=t.arguments.query?.resourceContext;break;default:return!0}return typeof r==`object`&&!!r&&!Array.isArray(r)&&r.key===t.context.resourceContextKey}function m(e){switch(e){case`unauthenticated`:return 401;case`forbidden`:return 403;case`not-found`:return 404;case`conflict`:return 409;case`limit-exceeded`:return 413;case`validation-failed`:return 422;case`rate-limited`:return 429;case`unavailable`:return 503;case`internal`:return 500;case`cancelled`:case`incompatible`:case`invalid-request`:return 400}}function h(e,t){return g(t,e)}function g(e,t){return{body:JSON.stringify(t),headers:i,status:e}}function _(e){return{...e,headers:{...e.headers,allow:`POST`}}}function v(e){let t=0;for(let n of e){let e=n.codePointAt(0)??0;t+=e<=127?1:e<=2047?2:e<=65535?3:4}return t}

package/dist/index.d.ts

@@ -1,6 +1,11 @@
-import { type BlockDefinition, type BlockSlotDefinition, type BlockType, type BlueprintDocument, type BlueprintBlockLock, type BlueprintNode, type JsonSchema, type StudioConfiguration, type StudioDiagnostic } from '@kumwe/studio-protocol';
-export { createHostRequestContextFixture, createTestbedHost, TestbedHostError, type HostRequestContextFixtureOptions, type TestbedControls, type TestbedHost, type TestbedHostOptions, type TestbedPortName, } from './host-testbed.js';
-export { createHttpHostAdapter, type HttpFetchLike, type HttpHostAdapterOptions, type HttpRequestInit, type HttpResponseLike, type HttpTimeoutHandle, } from './http-host-adapter.js';
+import { type StudioSchemaProfileErrorCode } from '@kumwe/studio-core';
+import { type BlockDefinition, type BlockSlotDefinition, type BlockType, type BlueprintDocument, type BlueprintBlockLock, type BlueprintNode, type ContentFieldKind, type ContentModelDocument, type DiagnosticLocation, type FieldDefinition, type JsonSchema, type StudioConfiguration, type StudioDiagnostic } from '@kumwe/studio-protocol';
+export { createHostRequestContextFixture, createTestbedHost, TestbedHostError, type HostRequestContextFixtureOptions, type TestbedAuthoringOperation, type TestbedAuthoringOptions, type TestbedAuthoringPlanFixture, type TestbedAuthoringSaveFixture, type TestbedAuthoringSaveRequest, type TestbedAuthoringStartFixture, type TestbedAuthoringTargetFixture, type TestbedAuthoringTypeFixture, type TestbedControls, type TestbedHost, type TestbedHostOptions, type TestbedPortName, type TestbedRateLimitPolicy, } from './host-testbed.js';
+export { createHttpHostAdapter, HTTP_HOST_OPERATION_ROUTES, type ConfiguredHttpHostAdapterOptions, type HttpAuthenticationConfiguration, type HttpAuthenticationRequest, type HttpAuthenticationResolver, type HttpBearerTokenAuthentication, type HttpFetchLike, type HttpHeaderTokenAuthentication, type HttpHostAdapterOptions, type HttpHostOperationEndpoints, type HttpHostOperationRoute, type HttpHostRoutingConfiguration, type HttpHostTransportConfiguration, type HttpRequestInit, type HttpResponseLike, type HttpSameOriginSessionAuthentication, type HttpTimeoutHandle, } from './http-host-adapter.js';
+export { AUTHORING_HTTP_OPERATIONS, AUTHORING_HTTP_OPERATIONS_BY_ROUTE, AUTHORING_HTTP_SCHEMA_ID, type AuthoringHttpOperationContract, type AuthoringHttpRoute, type HttpSchemaValidator, } from './http-authoring-contract.js';
+export { createAuthoringHttpResponder, type AuthoringHttpResponderOptions, type HttpResponderRequest, type HttpResponderResponse, type HttpTransportSecurityDecision, type HttpTransportSecurityInput, type HttpTransportSecurityVerifier, } from './http-host-responder.js';
+export { runAuthoringWebVector, type AuthoringWebAction, type AuthoringWebCommandObservation, type AuthoringWebConformanceAdapter, type AuthoringWebConformanceSession, type AuthoringWebGiven, type AuthoringWebLane, type AuthoringWebLaneResult, type AuthoringWebObservation, type AuthoringWebRegion, type AuthoringWebVector, type AuthoringWebVectorResult, } from './web-conformance.js';
+export { runContextualAuthoringStrideVector, type ContextualAuthoringCommandAssertion, type ContextualAuthoringConformanceAdapter, type ContextualAuthoringConformanceSession, type ContextualAuthoringLaunchAssertion, type ContextualAuthoringSaveAssertion, type ContextualAuthoringSaveRequest, type ContextualAuthoringStrideResult, type ContextualAuthoringStrideVector, } from './contextual-conformance.js';
 export interface BlueprintFixtureOptions {
     blockLocks?: BlueprintBlockLock[];
     id?: string;
@@ -19,6 +24,86 @@ export interface StudioConfigurationFixtureOptions {
     mode?: 'blueprint' | 'content' | 'model';
     sessionState?: 'editable' | 'read-only';
 }
+export interface SchemaProfileVectorInstance {
+    value: unknown;
+    valid: boolean;
+}
+/** Portable input consumed by `studio.profile/binding-projection-v1`. */
+export interface BindingProjectionVectorInput {
+    blockDefinitions: readonly BlockDefinition[];
+    blueprint: BlueprintDocument;
+    model: ContentModelDocument;
+}
+export interface BindingProjectionVectorCandidateResult {
+    cardinality: FieldDefinition['cardinality'];
+    control?: string;
+    fieldPath: string[];
+    itemKind?: Exclude<ContentFieldKind, 'collection'>;
+    kind: ContentFieldKind;
+}
+export interface BindingProjectionVectorPortResult {
+    bindingSourceKind?: string;
+    boundFieldPath?: string[];
+    candidates: BindingProjectionVectorCandidateResult[];
+    multiple?: boolean;
+    port: string;
+    required?: boolean;
+    status: 'invalid' | 'non-field-source' | 'resolved' | 'unbound';
+    valueType?: string;
+}
+export interface BindingProjectionVectorRunResult {
+    diagnostics: {
+        code: string;
+        location?: DiagnosticLocation;
+        severity: StudioDiagnostic['severity'];
+    }[];
+    model: BlueprintDocument['model'];
+    nodes: {
+        nodeId: string;
+        ports: BindingProjectionVectorPortResult[];
+    }[];
+}
+/**
+ * Replays a binding vector without consulting its expected projection. The
+ * normalized result intentionally excludes localized labels and prose so a
+ * non-TypeScript host compares stable coordinates, controls, outcomes, and
+ * diagnostic locations rather than an English rendering.
+ */
+export declare function runBindingProjectionVector(vector: BindingProjectionVectorInput): BindingProjectionVectorRunResult;
+export interface SchemaProfileVectorInput {
+    expect: {
+        outcome: 'accepted' | 'rejected';
+    };
+    schema: unknown;
+}
+export interface SchemaProfileVectorInstanceResult {
+    diagnostic?: {
+        instancePath: string;
+        keyword: string;
+    };
+    value: unknown;
+    valid: boolean;
+}
+export type SchemaProfileVectorRunResult = {
+    instances: SchemaProfileVectorInstanceResult[];
+    outcome: 'accepted';
+} | {
+    code: StudioSchemaProfileErrorCode;
+    outcome: 'rejected';
+    schemaPath: string;
+};
+/**
+ * Replay a portable `studio.profile/schema-property` vector against the
+ * reference implementation. Only each case's input `value` is read from the
+ * accepted expectation; expected verdicts and diagnostics are not consulted.
+ * Callers compare this independently produced outcome with the published
+ * `expect` member.
+ */
+export declare function runSchemaProfileVector(vector: SchemaProfileVectorInput & {
+    expect: {
+        instances?: SchemaProfileVectorInstance[];
+    };
+}): SchemaProfileVectorRunResult;
 export declare function createBlueprintFixture(options?: BlueprintFixtureOptions): BlueprintDocument;
 export declare function defineTestBlock(options: TestBlockOptions): BlockDefinition;
 export declare function createStudioConfigurationFixture(options?: StudioConfigurationFixtureOptions): StudioConfiguration;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,KAAK,SAAS,EACd,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,aAAa,EAClB,KAAK,UAAU,EACf,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACtB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EACL,+BAA+B,EAC/B,iBAAiB,EACjB,gBAAgB,EAChB,KAAK,gCAAgC,EACrC,KAAK,eAAe,EACpB,KAAK,WAAW,EAChB,KAAK,kBAAkB,EACvB,KAAK,eAAe,GACrB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,qBAAqB,EACrB,KAAK,aAAa,EAClB,KAAK,sBAAsB,EAC3B,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,GACvB,MAAM,wBAAwB,CAAC;AAEhC,MAAM,WAAW,uBAAuB;IACtC,UAAU,CAAC,EAAE,kBAAkB,EAAE,CAAC;IAClC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,aAAa,EAAE,CAAC;CACzB;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,UAAU,CAAC;IAC5B,KAAK,CAAC,EAAE,mBAAmB,EAAE,CAAC;IAC9B,IAAI,EAAE,SAAS,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,iCAAiC;IAChD,SAAS,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAChC,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,GAAG,OAAO,CAAC;IACzC,YAAY,CAAC,EAAE,UAAU,GAAG,WAAW,CAAC;CACzC;AAED,wBAAgB,sBAAsB,CAAC,OAAO,GAAE,uBAA4B,GAAG,iBAAiB,CAiB/F;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG,eAAe,CA2B1E;AAED,wBAAgB,gCAAgC,CAC9C,OAAO,GAAE,iCAAsC,GAC9C,mBAAmB,CAqErB;AAED,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,iBAAiB,EAC5B,WAAW,EAAE,SAAS,eAAe,EAAE,GACtC,IAAI,CAKN;AAED,qBAAa,sBAAuB,SAAQ,KAAK;IAC/C,SAAgB,WAAW,EAAE,gBAAgB,EAAE,CAAC;gBAE7B,WAAW,EAAE,gBAAgB,EAAE;CASnD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}