@rippling/rippling-sdk 0.2.0-alpha.83 → 0.2.0-alpha.85

package/src/core/platform/manifest/custom-objects/existing.ts

@@ -1,221 +0,0 @@
-import {
-  CustomObjectAction,
-  CustomObjectPageLayout,
-  ExistingManifestContext,
-  type ExistingManifestContextOptions,
-  ListViewDef,
-  Rule,
-  Validation,
-} from '../../../../lib/manifest';
-import type { AnyCustomObjectDefinition, FieldNames } from '../../custom-objects/types';
-import { getExistingManifestContext } from '../../../../lib/manifest/existing-manifest-context';
-import type { ManifestRegistration } from './types';
-
-/**
- * Typed binding result for one custom object loaded from an existing manifest.
- *
- * This mirrors the registration shape produced by `registerManifestCustomObject(...)`
- * while pointing at already-existing manifest components instead of creating new ones.
- * It is the typed anchor for existing-manifest extension work: callers can keep
- * using typed fields, sections, layouts, rules, validations, and actions that
- * already exist in the manifest, then drop to raw `lib/manifest` classes only
- * when they intentionally need an escape hatch for brand-new manifest-only
- * components that do not yet have a dedicated typed helper.
- *
- * @typeParam TDefinition - Typed custom-object definition bound to the loaded manifest components.
- */
-export interface ExistingManifestRegistration<TDefinition extends AnyCustomObjectDefinition>
-  extends ManifestRegistration<TDefinition> {
-  /** Existing-manifest context that resolved this binding. */
-  readonly context: ExistingManifestContext;
-  /** Loads one existing list view scoped to this custom object. */
-  loadListView(viewId: string): ListViewDef;
-  /** Loads one existing page layout scoped to this custom object. */
-  loadPageLayout(layoutIdOrApiName: string): CustomObjectPageLayout;
-  /** Loads one existing validation rule scoped to this custom object. */
-  loadValidation(ruleId: string): Validation;
-  /** Loads one existing record-triggered rule scoped to this custom object. */
-  loadRule(flowId: string): Rule;
-  /** Loads one existing object action scoped to this custom object. */
-  loadAction(actionId: string): CustomObjectAction;
-}
-
-/**
- * Options for {@link bindExistingManifestCustomObject}.
- *
- * @typeParam TDefinition - Typed custom-object definition being bound.
- */
-export interface BindExistingManifestCustomObjectOptions<TDefinition extends AnyCustomObjectDefinition>
-  extends ExistingManifestContextOptions {
-  /** Optional override for the custom-object API name to load. Defaults to `definition.apiName`. */
-  readonly customObjectApiName?: TDefinition['apiName'];
-  /** Optional override for the category API name to load. Defaults to `definition.categoryApiName`. */
-  readonly categoryApiName?: TDefinition['categoryApiName'];
-}
-
-/**
- * Options for {@link bindExistingManifestCustomObjects}.
- *
- * @typeParam TDefinitions - Ordered tuple of typed custom-object definitions being bound.
- */
-export interface BindExistingManifestCustomObjectsOptions<
-  TDefinitions extends readonly AnyCustomObjectDefinition[],
-> extends ExistingManifestContextOptions {
-  /** Ordered tuple of typed custom-object definitions to bind. */
-  readonly definitions: TDefinitions;
-}
-
-/**
- * Registration tuple returned by {@link bindExistingManifestCustomObjects}.
- *
- * @typeParam TDefinitions - Ordered tuple of object definitions that were bound.
- */
-export type ExistingManifestRegistrationTuple<TDefinitions extends readonly AnyCustomObjectDefinition[]> = {
-  readonly [TIndex in keyof TDefinitions]: TDefinitions[TIndex] extends AnyCustomObjectDefinition ?
-    ExistingManifestRegistration<TDefinitions[TIndex]>
-  : never;
-};
-
-function resolveSectionId<TDefinition extends AnyCustomObjectDefinition>(
-  definition: TDefinition,
-  sectionKey: Extract<keyof TDefinition['sections'], string>,
-  customObjectApiName: string,
-  context: ExistingManifestContext,
-): string {
-  const section = definition.sections[sectionKey];
-  if (section?.sectionId != null) {
-    return section.sectionId;
-  }
-
-  const fieldSectionIds = new Set<string>();
-  for (const fieldName of Object.keys(definition.fields) as FieldNames<TDefinition>[]) {
-    const field = definition.fields[fieldName];
-    if (field == null || field.section !== sectionKey) continue;
-    const loadedField = context.loadField(field.apiName, { customObjectApiName });
-    const sectionId = loadedField.getSectionId();
-    if (typeof sectionId === 'string' && sectionId.length > 0) {
-      fieldSectionIds.add(sectionId);
-    }
-  }
-
-  if (fieldSectionIds.size === 1) {
-    return [...fieldSectionIds][0]!;
-  }
-  if (fieldSectionIds.size > 1) {
-    throw new Error(
-      `Could not resolve one existing manifest section for key "${sectionKey}" on "${customObjectApiName}". ` +
-        `Fields in that section resolved to multiple section ids: ${[...fieldSectionIds]
-          .sort()
-          .join(', ')}. ` +
-        'Add a stable sectionId to the typed definition to disambiguate.',
-    );
-  }
-
-  throw new Error(
-    `Could not resolve existing manifest section key "${sectionKey}" for "${customObjectApiName}". ` +
-      'Add a stable sectionId to the typed definition or ensure at least one field in that section already exists in the manifest.',
-  );
-}
-
-/**
- * Binds one typed custom-object definition to components already present in an existing manifest.
- *
- * Use this helper when you want to mutate an installed or pre-authored manifest
- * through the typed custom-object lane instead of manually loading raw fields,
- * sections, layouts, and actions one by one.
- *
- * Current boundary: this helper rebinds the existing manifest back onto the
- * typed definition so downstream code can stay in logical typed names for the
- * common path, but it does not yet provide a fully typed builder for creating
- * brand-new fields or sections during an existing-manifest edit. When you need
- * that today, use this binding as the typed anchor and then drop to
- * `@rippling/rippling-sdk/lib/manifest` as the explicit escape hatch.
- *
- * @param definition - Typed custom-object definition that should bind to existing manifest components.
- * @param options - Existing-manifest context plus optional API-name overrides.
- * @returns Typed registration-like handle backed by existing manifest components.
- * @typeParam TDefinition - Object definition whose fields and sections should be bound.
- */
-export function bindExistingManifestCustomObject<TDefinition extends AnyCustomObjectDefinition>(
-  definition: TDefinition,
-  options: BindExistingManifestCustomObjectOptions<TDefinition> = {},
-): ExistingManifestRegistration<TDefinition> {
-  const context = getExistingManifestContext(options);
-  const customObjectApiName = options.customObjectApiName ?? definition.apiName;
-  const categoryApiName = options.categoryApiName ?? definition.categoryApiName;
-  const category = context.loadCategory(categoryApiName);
-  const object = context.loadCustomObject(customObjectApiName);
-
-  const sections = Object.freeze(
-    Object.fromEntries(
-      Object.keys(definition.sections).map((sectionKey) => {
-        const sectionId = resolveSectionId(
-          definition,
-          sectionKey as Extract<keyof TDefinition['sections'], string>,
-          customObjectApiName,
-          context,
-        );
-        return [
-          sectionKey,
-          context.loadFieldSection(sectionId, {
-            customObjectApiName,
-          }),
-        ];
-      }),
-    ),
-  ) as ExistingManifestRegistration<TDefinition>['sections'];
-
-  const fields = Object.freeze(
-    Object.fromEntries(
-      Object.keys(definition.fields).map((fieldName) => [
-        fieldName,
-        context.loadField(definition.fields[fieldName as FieldNames<TDefinition>]!.apiName, {
-          customObjectApiName,
-        }),
-      ]),
-    ),
-  ) as ExistingManifestRegistration<TDefinition>['fields'];
-
-  return Object.freeze({
-    context,
-    definition,
-    category,
-    object,
-    sections,
-    fields,
-    loadListView(viewId: string) {
-      return context.loadListView(viewId, { customObjectApiName });
-    },
-    loadPageLayout(layoutIdOrApiName: string) {
-      return context.loadPageLayout(layoutIdOrApiName, { customObjectApiName });
-    },
-    loadValidation(ruleId: string) {
-      return context.loadValidation(ruleId, { customObjectApiName });
-    },
-    loadRule(flowId: string) {
-      return context.loadRule(flowId, { customObjectApiName });
-    },
-    loadAction(actionId: string) {
-      return context.loadCustomObjectAction(actionId, { customObjectApiName });
-    },
-  });
-}
-
-/**
- * Binds multiple typed custom-object definitions to components already present in an existing manifest.
- *
- * @param options - Existing-manifest context plus the ordered tuple of definitions to bind.
- * @returns Ordered tuple of typed registration-like handles backed by existing manifest components.
- * @typeParam TDefinitions - Ordered tuple of object definitions to bind.
- */
-export function bindExistingManifestCustomObjects<TDefinitions extends readonly AnyCustomObjectDefinition[]>(
-  options: BindExistingManifestCustomObjectsOptions<TDefinitions>,
-): ExistingManifestRegistrationTuple<TDefinitions> {
-  return options.definitions.map((definition) =>
-    options.context != null ?
-      bindExistingManifestCustomObject(definition, {
-        context: options.context,
-      })
-    : bindExistingManifestCustomObject(definition),
-  ) as ExistingManifestRegistrationTuple<TDefinitions>;
-}

package/src/core/platform/manifest/custom-objects/field-resolution.ts

@@ -1,116 +0,0 @@
-import type { CustomObjectStandardFieldApiName, Field } from '../../../../lib/manifest';
-import type { AnyCustomObjectDefinition, FieldNames, StandardRecordFields } from '../../custom-objects/types';
-import type { ManifestRegistration } from './types';
-
-const STANDARD_TYPED_MANIFEST_FIELD_NAMES = [
-  'id',
-  'name',
-  'created_at',
-  'updated_at',
-  'system_updated_at',
-  'external_id',
-  'owner_role',
-  'created_by',
-  'last_modified_by',
-] as const satisfies readonly StandardManifestFieldName<AnyCustomObjectDefinition>[];
-
-const STANDARD_TYPED_MANIFEST_FIELD_NAME_SET = new Set<string>(STANDARD_TYPED_MANIFEST_FIELD_NAMES);
-
-/**
- * Standard field-name strings accepted by typed manifest helpers.
- *
- * These names intentionally use the record-shape snake_case surface rather than
- * the low-level manifest layer's camelCase aliases so authoring stays aligned
- * with typed records, validators, and create/update payload helpers.
- *
- * @typeParam TDefinition - Object definition whose standard record fields should be exposed.
- */
-export type StandardManifestFieldName<TDefinition extends AnyCustomObjectDefinition> = Extract<
-  keyof StandardRecordFields<TDefinition>,
-  string
->;
-
-/**
- * Field-name strings accepted by typed manifest helpers.
- *
- * The union combines the standard per-record fields present on every custom
- * object with the logical custom-field names declared in the typed schema.
- *
- * @typeParam TDefinition - Object definition whose valid field-name strings should be exposed.
- */
-export type TypedManifestFieldName<TDefinition extends AnyCustomObjectDefinition> =
-  | StandardManifestFieldName<TDefinition>
-  | FieldNames<TDefinition>;
-
-/**
- * Field inputs accepted by typed manifest helpers.
- *
- * Strings provide object-specific IntelliSense for standard and custom fields.
- * Concrete manifest {@link Field} references remain allowed for computed fields
- * such as summary fields that are created after the base schema is registered.
- *
- * @typeParam TDefinition - Object definition whose manifest field inputs are being authored.
- */
-export type TypedManifestFieldInput<TDefinition extends AnyCustomObjectDefinition> =
-  | TypedManifestFieldName<TDefinition>
-  | Field;
-
-/**
- * Type-safe `hasOwnProperty` helper for typed manifest field resolution.
- *
- * @param value - Object whose own properties should be checked.
- * @param key - Candidate property key.
- * @returns Whether the object owns that property.
- * @typeParam TObject - Object type being narrowed.
- */
-function hasOwn<TObject extends object>(
-  value: TObject,
-  key: PropertyKey,
-): key is Extract<keyof TObject, string | number | symbol> {
-  return Object.prototype.hasOwnProperty.call(value, key);
-}
-
-/**
- * Resolves one typed manifest field input into the concrete manifest {@link Field} instance.
- *
- * Assumptions:
- * - standard field names should autocomplete as snake_case strings
- * - custom typed fields should resolve from the manifest registration returned by
- *   the typed manifest registration helper
- * - computed fields like summary fields may still be passed directly as manifest field objects
- *
- * @param registration - Manifest registration produced from the typed object definition.
- * @param field - Typed field input to resolve.
- * @returns Concrete manifest field instance suitable for low-level manifest APIs.
- * @typeParam TDefinition - Object definition whose field reference is being resolved.
- */
-export function resolveTypedManifestField<TDefinition extends AnyCustomObjectDefinition>(
-  registration: ManifestRegistration<TDefinition>,
-  field: TypedManifestFieldInput<TDefinition>,
-): Field {
-  if (typeof field !== 'string') return field;
-
-  const matchesCustomField = hasOwn(registration.fields, field);
-  const matchesStandardField = STANDARD_TYPED_MANIFEST_FIELD_NAME_SET.has(field);
-
-  if (matchesCustomField && matchesStandardField) {
-    throw new Error(
-      `Field name "${field}" is ambiguous on "${registration.definition.apiName}" because it matches both a standard field and a custom field. ` +
-        'Pass an explicit manifest field reference instead.',
-    );
-  }
-  if (matchesCustomField) return registration.fields[field as FieldNames<TDefinition>] as unknown as Field;
-  if (matchesStandardField) {
-    return registration.object.standardField(field as CustomObjectStandardFieldApiName);
-  }
-
-  const validFieldNames = [
-    ...STANDARD_TYPED_MANIFEST_FIELD_NAMES,
-    ...Object.keys(registration.fields).sort(),
-  ];
-  throw new Error(
-    `Unknown field name "${field}" for "${
-      registration.definition.apiName
-    }". Valid field names: ${validFieldNames.join(', ')}.`,
-  );
-}

package/src/core/platform/manifest/custom-objects/function-file.ts

@@ -1,149 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import {
-  ManifestFunction,
-  type ManifestFunctionProps,
-  SduiPage,
-  type SduiPageProps,
-  type Workflow,
-} from '../../../../lib/manifest';
-import type { ManifestScope } from '../../../../lib/manifest/manifest-builder';
-import type { AnyCustomObjectDefinition } from '../../custom-objects/types';
-import { defineTypedWorkflow, type TypedWorkflowProps } from './workflow';
-
-/**
- * Shared properties for helpers that load manifest function source code from a
- * file on disk.
- */
-export interface ManifestFunctionFileSource {
-  /** Directory containing the function source file. */
-  readonly codeDirectory: string;
-  /** File name to read from {@link codeDirectory}. */
-  readonly codeFilename: string;
-}
-
-/**
- * Initialization properties for {@link defineManifestFunctionFromFile}.
- */
-export interface ManifestFunctionFromFileProps
-  extends Omit<ManifestFunctionProps, 'code'>,
-    ManifestFunctionFileSource {}
-
-/**
- * Initialization properties for {@link defineSduiPageFromFunctionFile}.
- */
-export interface SduiPageFromFunctionFileProps
-  extends Omit<SduiPageProps, 'function' | 'name' | 'sduiPageId'>,
-    ManifestFunctionFromFileProps {
-  /** Unique identifier for the SDUI page. */
-  readonly pageId: string;
-  /** Display name shown as the app tab label. */
-  readonly pageName: string;
-}
-
-/** Result returned by {@link defineSduiPageFromFunctionFile}. */
-export interface SduiPageFromFunctionFileResult {
-  /** Manifest function created from the provided source file. */
-  readonly function: ManifestFunction;
-  /** SDUI page wired to the created manifest function. */
-  readonly page: SduiPage;
-}
-
-/**
- * Initialization properties for {@link defineTypedWorkflowFromFunctionFile}.
- *
- * @typeParam TDefinition - Typed custom-object definition carried by the workflow trigger.
- */
-export interface TypedWorkflowFromFunctionFileProps<
-  TDefinition extends AnyCustomObjectDefinition = AnyCustomObjectDefinition,
-> extends Omit<TypedWorkflowProps<TDefinition>, 'function'> {
-  /** Function metadata and source-file location for the workflow handler. */
-  readonly function: ManifestFunctionFromFileProps;
-}
-
-/** Result returned by {@link defineTypedWorkflowFromFunctionFile}. */
-export interface TypedWorkflowFromFunctionFileResult {
-  /** Manifest function created from the provided source file. */
-  readonly function: ManifestFunction;
-  /** Workflow wired to the created manifest function. */
-  readonly workflow: Workflow;
-}
-
-/**
- * Loads one manifest function source file from disk.
- *
- * @param source - Directory + file-name pair describing the source file to read.
- * @returns UTF-8 TypeScript handler source.
- */
-export function loadManifestFunctionCode(source: ManifestFunctionFileSource): string {
-  return fs.readFileSync(path.join(source.codeDirectory, source.codeFilename), 'utf-8');
-}
-
-/**
- * Defines one manifest function by loading its handler source code from disk.
- *
- * @param scope - Manifest scope that should own the function.
- * @param props - Function properties plus the source-file location.
- * @returns Manifest function registered in the provided scope.
- */
-export function defineManifestFunctionFromFile(
-  scope: ManifestScope,
-  props: ManifestFunctionFromFileProps,
-): ManifestFunction {
-  const { codeDirectory, codeFilename, ...rest } = props;
-  return new ManifestFunction(scope, {
-    ...rest,
-    code: loadManifestFunctionCode({ codeDirectory, codeFilename }),
-  });
-}
-
-/**
- * Defines one SDUI page and its backing manifest function from a source file.
- *
- * @param scope - Manifest scope that should own the function and page.
- * @param props - Function properties, source-file location, and page wiring metadata.
- * @returns Created manifest function plus the SDUI page wired to it.
- */
-export function defineSduiPageFromFunctionFile(
-  scope: ManifestScope,
-  props: SduiPageFromFunctionFileProps,
-): SduiPageFromFunctionFileResult {
-  const { pageId, pageName, ...functionProps } = props;
-  const createdFunction = defineManifestFunctionFromFile(scope, functionProps);
-  return {
-    function: createdFunction,
-    page: new SduiPage(scope, {
-      sduiPageId: pageId,
-      name: pageName,
-      function: createdFunction,
-    }),
-  };
-}
-
-/**
- * Defines one workflow and its backing manifest function from a source file.
- *
- * Prefer this helper when one workflow owns one colocated handler file and the
- * caller wants the file loading plus workflow wiring in one step.
- *
- * @param scope - Manifest scope that should own the function and workflow.
- * @param props - Workflow properties plus the function source-file location.
- * @returns Created manifest function plus the workflow wired to it.
- * @typeParam TDefinition - Typed custom-object definition carried by the workflow trigger.
- */
-export function defineTypedWorkflowFromFunctionFile<
-  TDefinition extends AnyCustomObjectDefinition = AnyCustomObjectDefinition,
->(
-  scope: ManifestScope,
-  props: TypedWorkflowFromFunctionFileProps<TDefinition>,
-): TypedWorkflowFromFunctionFileResult {
-  const { function: functionProps, ...workflowProps } = props;
-  const createdFunction = defineManifestFunctionFromFile(scope, functionProps);
-  return {
-    function: createdFunction,
-    workflow: defineTypedWorkflow(scope, {
-      ...workflowProps,
-      function: createdFunction,
-    }),
-  };
-}

package/src/core/platform/manifest/custom-objects/list-view.ts

@@ -1,95 +0,0 @@
-import { ListViewDef, type ListViewDefProps } from '../../../../lib/manifest';
-import type { AnyCustomObjectDefinition } from '../../custom-objects/types';
-import type { ManifestConditionInput } from './conditions';
-import { resolveManifestConditionInput } from './conditions';
-import type { ManifestRegistration } from './types';
-import type {
-  StandardManifestFieldName,
-  TypedManifestFieldInput,
-  TypedManifestFieldName,
-} from './field-resolution';
-import { resolveTypedManifestField } from './field-resolution';
-
-/**
- * Standard field-name strings accepted by the typed list-view helper.
- *
- * @typeParam TDefinition - Object definition whose standard field-name strings should be exposed.
- */
-export type StandardListViewFieldName<TDefinition extends AnyCustomObjectDefinition> =
-  StandardManifestFieldName<TDefinition>;
-
-/**
- * Field-name strings accepted by the typed list-view helper.
- *
- * @typeParam TDefinition - Object definition whose valid list-view field-name strings should be exposed.
- */
-export type TypedListViewFieldName<TDefinition extends AnyCustomObjectDefinition> =
-  TypedManifestFieldName<TDefinition>;
-
-/**
- * Field inputs accepted by the typed list-view helper.
- *
- * @typeParam TDefinition - Object definition whose list-view field inputs are being authored.
- */
-export type TypedListViewFieldInput<TDefinition extends AnyCustomObjectDefinition> =
-  TypedManifestFieldInput<TDefinition>;
-
-/**
- * Initialization properties for {@link defineTypedListView}.
- *
- * @typeParam TDefinition - Object definition whose valid list-view fields should be enforced.
- */
-export interface TypedListViewDefProps<TDefinition extends AnyCustomObjectDefinition>
-  extends Omit<ListViewDefProps, 'fields' | 'orderBy' | 'rqlFilter'> {
-  /**
-   * Optional typed manifest-condition used to filter the list view.
-   *
-   * This is rendered into the underlying low-level `rqlFilter` string.
-   */
-  readonly filter?: ManifestConditionInput<TDefinition>;
-  /**
-   * Optional low-level filter string retained for escape hatches.
-   *
-   * Prefer `filter` for typed custom-object conditions when possible.
-   */
-  readonly rqlFilter?: string;
-  /**
-   * Columns to display, expressed as typed field-name strings or concrete manifest field references.
-   */
-  readonly fields: readonly TypedListViewFieldInput<TDefinition>[];
-  /**
-   * Optional field used for sorting. Accepts the same typed field inputs as `fields`.
-   */
-  readonly orderBy?: TypedListViewFieldInput<TDefinition>;
-}
-
-/**
- * Registers a typed list view for a manifest custom object.
- *
- * This helper sits on top of the low-level {@link ListViewDef} manifest class.
- * It preserves the runtime behavior of that class while replacing the untyped
- * `Field | string` authoring surface with an object-specific string-literal
- * union that powers IntelliSense for valid field names.
- *
- * @param registration - Manifest registration produced from the typed object definition.
- * @param props - Typed list-view properties to materialize into the manifest class.
- * @returns Low-level manifest list-view instance with typed fields resolved.
- * @typeParam TDefinition - Object definition whose valid list-view fields should be enforced.
- */
-export function defineTypedListView<TDefinition extends AnyCustomObjectDefinition>(
-  registration: ManifestRegistration<TDefinition>,
-  props: TypedListViewDefProps<TDefinition>,
-): ListViewDef {
-  const { fields, orderBy, filter, rqlFilter, ...rest } = props;
-  if (filter != null && rqlFilter != null) {
-    throw new Error('defineTypedListView(...): use either filter or rqlFilter, not both.');
-  }
-
-  return new ListViewDef(registration.object, {
-    ...rest,
-    fields: fields.map((field) => resolveTypedManifestField(registration, field)),
-    ...(orderBy != null ? { orderBy: resolveTypedManifestField(registration, orderBy) } : {}),
-    ...(filter != null ? { rqlFilter: resolveManifestConditionInput(registration, filter) } : {}),
-    ...(rqlFilter != null ? { rqlFilter } : {}),
-  });
-}

package/src/core/platform/manifest/custom-objects/object-list-page.ts

@@ -1,87 +0,0 @@
-import { ObjectListView, render } from '@rippling/pebble-sdui-web/catalogs/custom-apps';
-import { FunctionResponse, type FunctionContext, type SduiPageFunctionEvent } from '../../../../functions';
-
-/*
- * This helper intentionally depends on Pebble SDUI rendering. Consumers who use
- * this module should install `@rippling/pebble-sdui-web` alongside the SDK.
- */
-import type { AnyCustomObjectDefinition } from '../../custom-objects/types';
-import type { ManifestCustomObjectTarget } from './conditions';
-import type { ManifestRegistration } from './types';
-
-/**
- * Standard input shape for object-list page functions that only render their
- * initial SDUI page.
- */
-export type TypedObjectListPageInput = SduiPageFunctionEvent<{ action: 'init' }>;
-
-/**
- * Standard output body for object-list page functions that return one rendered
- * SDUI spec.
- */
-export interface TypedObjectListPageOutput {
-  /** JSON-serialized SDUI spec payload returned to the platform. */
-  readonly spec: string;
-}
-
-function isManifestRegistration<TDefinition extends AnyCustomObjectDefinition>(
-  target: ManifestCustomObjectTarget<TDefinition>,
-): target is ManifestRegistration<TDefinition> {
-  return typeof target === 'object' && target != null && 'definition' in target && 'object' in target;
-}
-
-function resolveObjectApiName<TDefinition extends AnyCustomObjectDefinition>(
-  target: ManifestCustomObjectTarget<TDefinition>,
-): string {
-  return isManifestRegistration(target) ? target.definition.apiName : target.apiName;
-}
-
-/**
- * Builds the standard SDUI function response for a custom-object-backed object
- * list page.
- *
- * @param target - Typed custom-object definition or manifest registration that owns the object list page.
- * @returns Function response containing the rendered ObjectListView spec.
- * @typeParam TDefinition - Typed custom-object definition whose API name should back the list page.
- */
-export function createTypedObjectListPageResponse<TDefinition extends AnyCustomObjectDefinition>(
-  target: ManifestCustomObjectTarget<TDefinition>,
-): FunctionResponse<TypedObjectListPageOutput> {
-  const spec = render({
-    root: ObjectListView({
-      props: { objectApiName: resolveObjectApiName(target) },
-    }),
-    state: {},
-  });
-
-  return new FunctionResponse<TypedObjectListPageOutput>({
-    body: { spec: JSON.stringify(spec) },
-    statusCode: 200,
-    headers: {},
-    message: '',
-  });
-}
-
-/**
- * Handles the standard custom-object object-list page event shape.
- *
- * The event and context are accepted so callers can keep an exported
- * `onRipplingEvent(event, context)` signature that matches backend IO-contract
- * derivation expectations, while delegating the repetitive response plumbing to
- * this helper.
- *
- * @param event - Incoming SDUI page event, expected to be the standard init-only object-list shape.
- * @param context - Function context supplied by the platform.
- * @param target - Typed custom-object definition or manifest registration that owns the object list page.
- * @returns Function response containing the rendered ObjectListView spec.
- * @typeParam TDefinition - Typed custom-object definition whose API name should back the list page.
- */
-export async function handleTypedObjectListPageEvent<TDefinition extends AnyCustomObjectDefinition>(
-  event: TypedObjectListPageInput,
-  context: FunctionContext,
-  target: ManifestCustomObjectTarget<TDefinition>,
-): Promise<FunctionResponse<TypedObjectListPageOutput>> {
-  void event;
-  void context;
-  return createTypedObjectListPageResponse(target);
-}