carrick 0.3.100 → 0.3.102

package/sidecar/dist/src/validators.js

@@ -349,6 +349,120 @@ export const VerifyClientSemanticsRequestSchema = BaseRequestSchema.extend({
     checks: z.array(SemanticsCheckSchema),
     budget_ms: z.number().int().nonnegative().optional(),
 });
+/** Where one part of a library call sits (carrick#1616). */
+const ClaimSlotSchema = z
+    .object({
+    arg: z.number().int().nonnegative(),
+    key: z.string().min(1).optional(),
+})
+    .strict();
+const BoundNameSchema = z.object({ bound: z.enum(['maker', 'scope']) }).strict();
+const ClaimOnSchema = z.enum(['export', 'instance', 'both']);
+const MemberPathSchema = z.array(z.string().min(1));
+const KeyLabelsSchema = z.record(z.string().min(1), z.enum(['name', 'not_name']));
+/** Carried for the scanner, never read. */
+const NameScopeSchema = z
+    .object({ scope: z.enum(['global', 'service']), namespace: z.string().min(1).nullable() })
+    .strict();
+/**
+ * One claim element in the shape the store answers, tagged by `kind`
+ * (contract on carrick#1564, sections 2 and 3, as amendment 2 changes them).
+ * A maker's parts are slots; `on` and `of` are checked against each other by
+ * the verifier (`claim_invalid`), not here.
+ */
+const LibraryClaimSchema = z.discriminatedUnion('kind', [
+    z
+        .object({
+        kind: z.literal('make'),
+        form: z.enum(['call', 'new']),
+        member: z.string().min(1).nullable(),
+        base: ClaimSlotSchema.optional(),
+        prefix: ClaimSlotSchema.optional(),
+        name: ClaimSlotSchema.optional(),
+        handler: ClaimSlotSchema.optional(),
+        key_labels: KeyLabelsSchema.optional(),
+        name_scope: NameScopeSchema.optional(),
+        picker: z.string().optional(),
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal('scope'),
+        member: z.string().min(1),
+        name: ClaimSlotSchema,
+        path: MemberPathSchema.optional(),
+        on: ClaimOnSchema.optional(),
+        of: z.string().min(1).optional(),
+        key_labels: KeyLabelsSchema.optional(),
+        name_scope: NameScopeSchema.optional(),
+        picker: z.string().optional(),
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal('op'),
+        op: z.enum(['request', 'send', 'receive', 'execute']),
+        member: z.string().min(1).nullable(),
+        path: MemberPathSchema.optional(),
+        on: ClaimOnSchema.optional(),
+        of: z.string().min(1).optional(),
+        name: z.union([BoundNameSchema, ClaimSlotSchema]).optional(),
+        payload: ClaimSlotSchema.optional(),
+        handler: ClaimSlotSchema.optional(),
+        ack: ClaimSlotSchema.optional(),
+        key_labels: KeyLabelsSchema.optional(),
+        name_scope: NameScopeSchema.optional(),
+        picker: z.string().optional(),
+        options: ClaimSlotSchema.optional(),
+        method: z.string().min(1).optional(),
+        method_key: ClaimSlotSchema.optional(),
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal('reserved'),
+        member: z.string().min(1),
+        name: z.string().min(1),
+        path: MemberPathSchema.optional(),
+        on: ClaimOnSchema.optional(),
+        of: z.string().min(1).optional(),
+        picker: z.string().optional(),
+    })
+        .strict(),
+]);
+const LibraryCheckSchema = z
+    .object({
+    claim_id: z.string().min(1),
+    package: z.string().min(1),
+    export: z.string().min(1),
+    role: z.enum([
+        'http_client',
+        'graphql_client',
+        'broker',
+        'in_process_bus',
+        'socket',
+        'server_framework',
+        'none',
+    ]),
+    // Any other receiver answers `unchecked` (`receiver_invalid`) on its own.
+    receiver: z.string().min(1),
+    claim: LibraryClaimSchema,
+})
+    .strict();
+export const VerifyLibraryClaimsRequestSchema = BaseRequestSchema.extend({
+    action: z.literal('verify_library_claims'),
+    from_dir: z.string().min(1),
+    checks: z.array(LibraryCheckSchema),
+    // The contract's sample sends `null` for "no budget of the request's own".
+    budget_ms: z.number().int().nonnegative().nullable().optional(),
+});
+export const ListLibrarySurfaceRequestSchema = BaseRequestSchema.extend({
+    action: z.literal('list_library_surface'),
+    from_dir: z.string().min(1),
+    packages: z.array(z.string().min(1)),
+    max_entries: z.number().int().positive().optional(),
+    exports: z.record(z.string(), z.array(z.string().min(1))).optional(),
+});
 // ============================================================================
 // Discriminated Union Schema
 // ============================================================================
@@ -367,6 +481,8 @@ export const SidecarRequestSchema = z.discriminatedUnion('action', [
     ResolveDefinitionsRequestSchema,
     RetypeCheckRequestSchema,
     VerifyClientSemanticsRequestSchema,
+    VerifyLibraryClaimsRequestSchema,
+    ListLibrarySurfaceRequestSchema,
     HealthRequestSchema,
     ShutdownRequestSchema,
 ]);

package/sidecar/dist/src/client-semantics.d.ts

@@ -1,36 +0,0 @@
-/**
- * `verify_client_semantics` (carrick#1564): check what a model said about an
- * HTTP client library against the package's own type declarations.
- *
- * A claim names a member of a package export (or of an instance one of its
- * factories returns) and says how that member is called: which option key
- * carries the base URL, which HTTP method a verb sends, where the path, method
- * and body sit. The scanner reads call sites through a claim only when this
- * check verified it, and a verified claim becomes a fact that can fail a pull
- * request check. So a claim is `verified` only when the declarations say so
- * positively. `failed` means the declarations resolved and contradict the
- * claim; `unchecked` means they could not be read, or say nothing at the place
- * the claim needs (`any`, `unknown`, `{}`, an unconstrained type parameter).
- * The scanner drops both.
- *
- * The export's type is read the way the service's own code would read it: a
- * probe file in `from_dir` imports it, inside the service's program, under the
- * service's compiler options. The declarations must be the installed
- * package's: a `paths` alias or a `declare module` block the service writes
- * for itself is not evidence about the library.
- */
-import { type Project } from 'ts-morph';
-import type { SemanticsCheck, SemanticsModule, SemanticsResult } from './types.js';
-export interface VerifyResult {
-    semantics: SemanticsResult[];
-    modules: SemanticsModule[];
-}
-export declare class ClientSemanticsVerifier {
-    private readonly project;
-    constructor(project: Project);
-    /**
-     * Judge every check, in request order, spending at most `budgetMs`. Checks
-     * the budget does not reach come back `unchecked` with reason `budget`.
-     */
-    run(fromDir: string, checks: SemanticsCheck[], budgetMs: number): VerifyResult;
-}